void
NumericOutput::EmitWarnings(Diagnostic& diags) const
{
if (m_sign && (m_warns & INT_OVERFLOW) != 0)
diags.Report(m_source, diag::warn_signed_overflow) << m_size;
if (!m_sign && (m_warns & INT_OVERFLOW) != 0)
diags.Report(m_source, diag::warn_unsigned_overflow) << m_size;
if ((m_warns & FP_UNDERFLOW) != 0)
diags.Report(m_source, diag::warn_float_underflow);
if ((m_warns & FP_OVERFLOW) != 0)
diags.Report(m_source, diag::warn_float_overflow);
if ((m_warns & TRUNCATED) != 0)
diags.Report(m_source, diag::warn_truncated) << m_rshift;
}
void Particle::UpdateDiagnostics(Diagnostic& renderer)
{
if(renderer.AllowDiagnostics(Diagnostic::TEXT))
{
renderer.UpdateText(Diagnostic::TEXT, "Particle Delta",
Diagnostic::WHITE, StringCast(m_positionDelta.y));;
renderer.UpdateText(Diagnostic::TEXT,
"Particle Collision", Diagnostic::WHITE, std::string(
(m_collision->IsCollidingWith(Geometry::NONE) ? "NONE " : "")) +
(m_collision->IsCollidingWith(Geometry::SPHERE) ? "SPHERE " : "") +
(m_collision->IsCollidingWith(Geometry::BOX) ? "BOX " : "") +
(m_collision->IsCollidingWith(Geometry::CYLINDER) ? "CYLINDER " : ""));
}
}
void
Win64Object::DirPushReg(DirectiveInfo& info, Diagnostic& diags)
{
assert(info.isObject(m_object));
NameValues& namevals = info.getNameValues();
assert(!namevals.empty());
if (!CheckProcFrameState(info.getSource(), diags))
return;
if (!namevals.front().isRegister())
{
diags.Report(info.getSource(), diag::err_value_register)
<< namevals.front().getValueRange();
return;
}
const Register* reg = namevals.front().getRegister();
// Generate a PUSH_NONVOL unwind code.
m_unwind->AddCode(std::auto_ptr<UnwindCode>(new UnwindCode(
m_unwind->getProc(),
m_object.getSymbol(info.getLocation()),
UnwindCode::PUSH_NONVOL,
reg->getNum() & 0xF)));
}
void
Win64Object::DirAllocStack(DirectiveInfo& info, Diagnostic& diags)
{
assert(info.isObject(m_object));
NameValues& namevals = info.getNameValues();
assert(!namevals.empty());
if (!CheckProcFrameState(info.getSource(), diags))
return;
NameValue& nv = namevals.front();
if (!nv.isExpr())
{
diags.Report(info.getSource(), diag::err_value_expression)
<< nv.getValueRange();
return;
}
// Generate an ALLOC_SMALL unwind code; this will get enlarged to an
// ALLOC_LARGE if necessary.
m_unwind->AddCode(std::auto_ptr<UnwindCode>(new UnwindCode(
m_unwind->getProc(),
m_object.getSymbol(info.getLocation()),
UnwindCode::ALLOC_SMALL,
0,
7,
nv.ReleaseExpr(m_object))));
}
bool
yasm::DirNameValueWarn(NameValue& nv,
SourceLocation dir_source,
Diagnostic& diags)
{
if (nv.getNameSource().isValid())
{
diags.Report(nv.getNameSource(), diag::warn_unrecognized_qualifier);
return false;
}
diags.Report(nv.getValueRange().getBegin(),
diag::warn_unrecognized_qualifier);
return false;
}
unsigned SDiagsWriter::getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel,
const Diagnostic &Info) {
if (DiagLevel == DiagnosticsEngine::Note)
return 0; // No flag for notes.
StringRef FlagName = DiagnosticIDs::getWarningOptionForDiag(Info.getID());
if (FlagName.empty())
return 0;
// Here we assume that FlagName points to static data whose pointer
// value is fixed. This allows us to unique by diagnostic groups.
const void *data = FlagName.data();
std::pair<unsigned, StringRef> &entry = DiagFlags[data];
if (entry.first == 0) {
entry.first = DiagFlags.size();
entry.second = FlagName;
// Lazily emit the string in a separate record.
RecordData Record;
Record.push_back(RECORD_DIAG_FLAG);
Record.push_back(entry.first);
Record.push_back(FlagName.size());
Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_DIAG_FLAG),
Record, FlagName);
}
return entry.first;
}
void
ElfSymbol::Write(Bytes& bytes, const ElfConfig& config, Diagnostic& diags)
{
// Pull referenced elf symbol information type and size
if (m_value_rel)
{
ElfSymbol* elfrel = m_value_rel->getAssocData<ElfSymbol>();
if (elfrel)
{
if (!hasType() && elfrel->hasType())
m_type = elfrel->m_type;
if (!hasSize() && elfrel->hasSize())
{
m_size = elfrel->m_size;
m_size_source = elfrel->m_size_source;
// just in case, simplify it
SimplifyCalcDist(m_size, diags);
if (!m_size.isIntNum())
diags.Report(m_size_source, diag::err_size_integer);
}
}
}
bytes.resize(0);
config.setEndian(bytes);
Write32(bytes, m_name_index);
if (config.cls == ELFCLASS32)
{
Write32(bytes, m_value);
Write32(bytes, hasSize() && m_size.isIntNum() ? m_size.getIntNum() : 0);
}
Write8(bytes, ELF_ST_INFO(m_bind, m_type));
Write8(bytes, ELF_ST_OTHER(m_vis));
if (m_sect)
{
ElfSection* elfsect = m_sect->getAssocData<ElfSection>();
assert(elfsect != 0);
Write16(bytes, elfsect->getIndex());
}
else
{
Write16(bytes, m_index);
}
if (config.cls == ELFCLASS64)
{
Write64(bytes, m_value);
Write64(bytes, hasSize() ? m_size.getIntNum() : 0);
}
if (config.cls == ELFCLASS32)
assert(bytes.size() == SYMTAB32_SIZE);
else if (config.cls == ELFCLASS64)
assert(bytes.size() == SYMTAB64_SIZE);
}
void LogDiagnosticPrinter::HandleDiagnostic(DiagnosticsEngine::Level Level,
const Diagnostic &Info) {
// Default implementation (Warnings/errors count).
DiagnosticConsumer::HandleDiagnostic(Level, Info);
// Initialize the main file name, if we haven't already fetched it.
if (MainFilename.empty() && Info.hasSourceManager()) {
const SourceManager &SM = Info.getSourceManager();
FileID FID = SM.getMainFileID();
if (!FID.isInvalid()) {
const FileEntry *FE = SM.getFileEntryForID(FID);
if (FE && FE->getName())
MainFilename = FE->getName();
}
}
// Create the diag entry.
DiagEntry DE;
DE.DiagnosticID = Info.getID();
DE.DiagnosticLevel = Level;
// Format the message.
SmallString<100> MessageStr;
Info.FormatDiagnostic(MessageStr);
DE.Message = MessageStr.str();
// Set the location information.
DE.Filename = "";
DE.Line = DE.Column = 0;
if (Info.getLocation().isValid() && Info.hasSourceManager()) {
const SourceManager &SM = Info.getSourceManager();
PresumedLoc PLoc = SM.getPresumedLoc(Info.getLocation());
if (PLoc.isInvalid()) {
// At least print the file name if available:
FileID FID = SM.getFileID(Info.getLocation());
if (!FID.isInvalid()) {
const FileEntry *FE = SM.getFileEntryForID(FID);
if (FE && FE->getName())
DE.Filename = FE->getName();
}
} else {
DE.Filename = PLoc.getFilename();
DE.Line = PLoc.getLine();
DE.Column = PLoc.getColumn();
}
}
// Record the diagnostic entry.
Entries.push_back(DE);
}
void ClangTidyDiagnosticConsumer::HandleDiagnostic(
DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
// FIXME: Demultiplex diagnostics.
// FIXME: Ensure that we don't get notes from user code related to errors
// from non-user code.
if (Diags->getSourceManager().isInSystemHeader(Info.getLocation()))
return;
if (DiagLevel != DiagnosticsEngine::Note) {
Errors.push_back(
ClangTidyError(Context.getCheckName(Info.getID()), getMessage(Info)));
} else {
assert(!Errors.empty() &&
"A diagnostic note can only be appended to a message.");
Errors.back().Notes.push_back(getMessage(Info));
}
addFixes(Info, Errors.back());
}
void SDiagsWriter::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
const Diagnostic &Info) {
if (DiagLevel != DiagnosticsEngine::Note) {
if (inNonNoteDiagnostic) {
// We have encountered a non-note diagnostic. Finish up the previous
// diagnostic block before starting a new one.
Stream.ExitBlock();
}
inNonNoteDiagnostic = true;
}
// Compute the diagnostic text.
diagBuf.clear();
Info.FormatDiagnostic(diagBuf);
const SourceManager *
SM = Info.hasSourceManager() ? &Info.getSourceManager() : 0;
SDiagsRenderer Renderer(*this, Record, *LangOpts, DiagOpts);
Renderer.emitDiagnostic(Info.getLocation(), DiagLevel,
diagBuf.str(),
Info.getRanges(),
llvm::makeArrayRef(Info.getFixItHints(),
Info.getNumFixItHints()),
SM,
&Info);
}
void
Win64Object::SaveCommon(DirectiveInfo& info,
UnwindCode::Opcode op,
Diagnostic& diags)
{
assert(info.isObject(m_object));
NameValues& namevals = info.getNameValues();
SourceLocation source = info.getSource();
assert(!namevals.empty());
if (!CheckProcFrameState(info.getSource(), diags))
return;
if (!namevals.front().isRegister())
{
diags.Report(source, diag::err_value_register)
<< namevals.front().getValueRange();
return;
}
const Register* reg = namevals.front().getRegister();
if (namevals.size() < 2)
{
diags.Report(source, diag::err_no_offset);
return;
}
if (!namevals[1].isExpr())
{
diags.Report(source, diag::err_offset_expression)
<< namevals[1].getValueRange();
return;
}
// Generate a SAVE_XXX unwind code; this will get enlarged to a
// SAVE_XXX_FAR if necessary.
m_unwind->AddCode(std::auto_ptr<UnwindCode>(new UnwindCode(
m_unwind->getProc(),
m_object.getSymbol(info.getLocation()),
op,
reg->getNum() & 0xF,
16,
namevals[1].ReleaseExpr(m_object))));
}
// Initialize the remapping of files to alternative contents, e.g.,
// those specified through other files.
static void InitializeFileRemapping(Diagnostic &Diags,
SourceManager &SourceMgr,
FileManager &FileMgr,
const PreprocessorOptions &InitOpts) {
// Remap files in the source manager.
for (PreprocessorOptions::remapped_file_iterator
Remap = InitOpts.remapped_file_begin(),
RemapEnd = InitOpts.remapped_file_end();
Remap != RemapEnd;
++Remap) {
// Find the file that we're mapping to.
const FileEntry *ToFile = FileMgr.getFile(Remap->second);
if (!ToFile) {
Diags.Report(diag::err_fe_remap_missing_to_file)
<< Remap->first << Remap->second;
continue;
}
// Create the file entry for the file that we're mapping from.
const FileEntry *FromFile = FileMgr.getVirtualFile(Remap->first,
ToFile->getSize(),
0);
if (!FromFile) {
Diags.Report(diag::err_fe_remap_missing_from_file)
<< Remap->first;
continue;
}
// Load the contents of the file we're mapping to.
std::string ErrorStr;
const llvm::MemoryBuffer *Buffer
= llvm::MemoryBuffer::getFile(ToFile->getName(), &ErrorStr);
if (!Buffer) {
Diags.Report(diag::err_fe_error_opening)
<< Remap->second << ErrorStr;
continue;
}
// Override the contents of the "from" file with the contents of
// the "to" file.
SourceMgr.overrideFileContents(FromFile, Buffer);
}
}
bool
Multiple::CalcForOutput(SourceLocation source, Diagnostic& diags)
{
SimplifyCalcDist(m_expr, diags);
if (!m_expr.isIntNum())
{
diags.Report(source, diag::err_multiple_unknown);
return false;
}
IntNum num = m_expr.getIntNum();
if (num.getSign() < 0)
{
diags.Report(source, diag::err_multiple_negative);
return false;
}
assert(m_int == num.getInt() && "multiple changed after optimize");
m_int = num.getInt();
return true;
}
void Geometry::UpdateDiagnostics(Diagnostic& renderer, const D3DXMATRIX& world)
{
if(renderer.AllowDiagnostics(Diagnostic::MESH))
{
std::string id = StringCast(this);
const auto& faces = GetFaces();
const float normalsize = 0.6f;
for(unsigned int i = 0; i < faces.size(); ++i)
{
D3DXVECTOR3 center, normal;
D3DXVec3TransformCoord(¢er, &faces[i].center, &world);
D3DXVec3TransformNormal(&normal, &faces[i].normal, &world);
D3DXVec3Normalize(&normal, &normal);
renderer.UpdateLine(Diagnostic::MESH, "FaceNormal" +
StringCast(i) + id, Diagnostic::CYAN,
center, center + (normal * normalsize));
}
}
}
void TextDiagnosticPrinter::HandleDiagnostic(DiagnosticsEngine::Level Level,
const Diagnostic &Info) {
// Default implementation (Warnings/errors count).
DiagnosticConsumer::HandleDiagnostic(Level, Info);
// Render the diagnostic message into a temporary buffer eagerly. We'll use
// this later as we print out the diagnostic to the terminal.
SmallString<100> OutStr;
Info.FormatDiagnostic(OutStr);
llvm::raw_svector_ostream DiagMessageStream(OutStr);
printDiagnosticOptions(DiagMessageStream, Level, Info, *DiagOpts);
// Keeps track of the the starting position of the location
// information (e.g., "foo.c:10:4:") that precedes the error
// message. We use this information to determine how long the
// file+line+column number prefix is.
uint64_t StartOfLocationInfo = OS.tell();
if (!Prefix.empty())
OS << Prefix << ": ";
// Use a dedicated, simpler path for diagnostics without a valid location.
// This is important as if the location is missing, we may be emitting
// diagnostics in a context that lacks language options, a source manager, or
// other infrastructure necessary when emitting more rich diagnostics.
if (!Info.getLocation().isValid()) {
TextDiagnostic::printDiagnosticLevel(OS, Level, DiagOpts->ShowColors);
TextDiagnostic::printDiagnosticMessage(OS, Level, DiagMessageStream.str(),
OS.tell() - StartOfLocationInfo,
DiagOpts->MessageLength,
DiagOpts->ShowColors);
OS.flush();
return;
}
// Assert that the rest of our infrastructure is setup properly.
assert(DiagOpts && "Unexpected diagnostic without options set");
assert(Info.hasSourceManager() &&
"Unexpected diagnostic with no source manager");
assert(TextDiag && "Unexpected diagnostic outside source file processing");
TextDiag->emitDiagnostic(Info.getLocation(), Level, DiagMessageStream.str(),
Info.getRanges(),
llvm::makeArrayRef(Info.getFixItHints(),
Info.getNumFixItHints()),
&Info.getSourceManager());
OS.flush();
}
// Diagnostics
static void SetUpBuildDumpLog(const DiagnosticOptions &DiagOpts,
unsigned argc, const char* const *argv,
Diagnostic &Diags) {
std::string ErrorInfo;
llvm::OwningPtr<llvm::raw_ostream> OS(
new llvm::raw_fd_ostream(DiagOpts.DumpBuildInformation.c_str(), ErrorInfo));
if (!ErrorInfo.empty()) {
Diags.Report(diag::err_fe_unable_to_open_logfile)
<< DiagOpts.DumpBuildInformation << ErrorInfo;
return;
}
(*OS) << "clang -cc1 command line arguments: ";
for (unsigned i = 0; i != argc; ++i)
(*OS) << argv[i] << ' ';
(*OS) << '\n';
// Chain in a diagnostic client which will log the diagnostics.
DiagnosticClient *Logger =
new TextDiagnosticPrinter(*OS.take(), DiagOpts, /*OwnsOutputStream=*/true);
Diags.setClient(new ChainedDiagnosticClient(Diags.takeClient(), Logger));
}
/// HandleDiagnostic - Store the errors, warnings, and notes that are
/// reported.
///
void TextDiagnosticBuffer::HandleDiagnostic(DiagnosticsEngine::Level Level,
const Diagnostic &Info) {
// Default implementation (Warnings/errors count).
DiagnosticConsumer::HandleDiagnostic(Level, Info);
SmallString<100> Buf;
Info.FormatDiagnostic(Buf);
switch (Level) {
default: llvm_unreachable(
"Diagnostic not handled during diagnostic buffering!");
case DiagnosticsEngine::Note:
Notes.push_back(std::make_pair(Info.getLocation(), Buf.str()));
break;
case DiagnosticsEngine::Warning:
Warnings.push_back(std::make_pair(Info.getLocation(), Buf.str()));
break;
case DiagnosticsEngine::Error:
case DiagnosticsEngine::Fatal:
Errors.push_back(std::make_pair(Info.getLocation(), Buf.str()));
break;
}
}
void VerifyDiagnosticConsumer::HandleDiagnostic(
DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
if (Info.hasSourceManager()) {
// If this diagnostic is for a different source manager, ignore it.
if (SrcManager && &Info.getSourceManager() != SrcManager)
return;
setSourceManager(Info.getSourceManager());
}
#ifndef NDEBUG
// Debug build tracks unparsed files for possible
// unparsed expected-* directives.
if (SrcManager) {
SourceLocation Loc = Info.getLocation();
if (Loc.isValid()) {
ParsedStatus PS = IsUnparsed;
Loc = SrcManager->getExpansionLoc(Loc);
FileID FID = SrcManager->getFileID(Loc);
const FileEntry *FE = SrcManager->getFileEntryForID(FID);
if (FE && CurrentPreprocessor && SrcManager->isLoadedFileID(FID)) {
// If the file is a modules header file it shall not be parsed
// for expected-* directives.
HeaderSearch &HS = CurrentPreprocessor->getHeaderSearchInfo();
if (HS.findModuleForHeader(FE))
PS = IsUnparsedNoDirectives;
}
UpdateParsedFileStatus(*SrcManager, FID, PS);
}
}
#endif
// Send the diagnostic to the buffer, we will check it once we reach the end
// of the source file (or are destructed).
Buffer->HandleDiagnostic(DiagLevel, Info);
}
static int getLastArgIntValue(ArgList &Args, cc1options::ID ID,
int Default, Diagnostic &Diags) {
Arg *A = Args.getLastArg(ID);
if (!A)
return Default;
int Res = Default;
if (llvm::StringRef(A->getValue(Args)).getAsInteger(10, Res))
Diags.Report(diag::err_drv_invalid_int_value)
<< A->getAsString(Args) << A->getValue(Args);
return Res;
}
bool
BinObject::setMapFilename(const NameValue& nv,
SourceLocation dir_source,
Diagnostic& diags)
{
if (!m_map_filename.empty())
{
diags.Report(nv.getValueRange().getBegin(),
diags.getCustomDiagID(Diagnostic::Error,
"map file already specified"));
return true;
}
if (!nv.isString())
{
diags.Report(nv.getValueRange().getBegin(),
diag::err_value_string_or_id);
return false;
}
m_map_filename = nv.getString();
return true;
}
static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args,
Diagnostic &Diags) {
using namespace cc1options;
Opts.ImplicitPCHInclude = getLastArgValue(Args, OPT_include_pch);
Opts.ImplicitPTHInclude = getLastArgValue(Args, OPT_include_pth);
if (const Arg *A = Args.getLastArg(OPT_token_cache))
Opts.TokenCache = A->getValue(Args);
else
Opts.TokenCache = Opts.ImplicitPTHInclude;
Opts.UsePredefines = !Args.hasArg(OPT_undef);
// Add macros from the command line.
for (arg_iterator it = Args.filtered_begin(OPT_D, OPT_U),
ie = Args.filtered_end(); it != ie; ++it) {
if (it->getOption().matches(OPT_D))
Opts.addMacroDef(it->getValue(Args));
else
Opts.addMacroUndef(it->getValue(Args));
}
Opts.MacroIncludes = getAllArgValues(Args, OPT_imacros);
// Add the ordered list of -includes.
for (arg_iterator it = Args.filtered_begin(OPT_include, OPT_include_pch,
OPT_include_pth),
ie = Args.filtered_end(); it != ie; ++it) {
// PCH is handled specially, we need to extra the original include path.
if (it->getOption().matches(OPT_include_pch)) {
std::string OriginalFile =
PCHReader::getOriginalSourceFile(it->getValue(Args), Diags);
if (OriginalFile.empty())
continue;
Opts.Includes.push_back(OriginalFile);
} else
Opts.Includes.push_back(it->getValue(Args));
}
for (arg_iterator it = Args.filtered_begin(OPT_remap_file),
ie = Args.filtered_end(); it != ie; ++it) {
std::pair<llvm::StringRef,llvm::StringRef> Split =
llvm::StringRef(it->getValue(Args)).split(';');
if (Split.second.empty()) {
Diags.Report(diag::err_drv_invalid_remap_file) << it->getAsString(Args);
continue;
}
Opts.addRemappedFile(Split.first, Split.second);
}
}
static void MapGroupMembers(const WarningOption *Group, diag::Mapping Mapping,
Diagnostic &Diags) {
// Option exists, poke all the members of its diagnostic set.
if (const short *Member = Group->Members) {
for (; *Member != -1; ++Member)
Diags.setDiagnosticMapping(*Member, Mapping);
}
// Enable/disable all subgroups along with this one.
if (const char *SubGroups = Group->SubGroups) {
for (; *SubGroups != (char)-1; ++SubGroups)
MapGroupMembers(&OptionTable[(unsigned char)*SubGroups], Mapping, Diags);
}
}
void
BinObject::DirOrg(DirectiveInfo& info, Diagnostic& diags)
{
// We only allow a single ORG in a program.
if (m_org.get() != 0)
{
diags.Report(info.getSource(),
diags.getCustomDiagID(Diagnostic::Error,
"program origin redefined"));
return;
}
// ORG takes just a simple expression as param
const NameValue& nv = info.getNameValues().front();
if (!nv.isExpr())
{
diags.Report(info.getSource(), diag::err_value_expression)
<< nv.getValueRange();
return;
}
m_org.reset(new Expr(nv.getExpr(info.getObject())));
m_org_source = info.getSource();
}
static void MapGroupMembers(const WarningOption *Group, diag::Mapping Mapping,
SourceLocation Loc, Diagnostic &Diag) {
// Option exists, poke all the members of its diagnostic set.
if (const short *Member = Group->Members) {
for (; *Member != -1; ++Member)
Diag.setDiagnosticMapping(*Member, Mapping, Loc);
}
// Enable/disable all subgroups along with this one.
if (const short *SubGroups = Group->SubGroups) {
for (; *SubGroups != (short)-1; ++SubGroups)
MapGroupMembers(&OptionTable[(short)*SubGroups], Mapping, Loc, Diag);
}
}
void SDiagsWriter::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
const Diagnostic &Info) {
// Enter the block for a non-note diagnostic immediately, rather than waiting
// for beginDiagnostic, in case associated notes are emitted before we get
// there.
if (DiagLevel != DiagnosticsEngine::Note) {
if (State->EmittedAnyDiagBlocks)
ExitDiagBlock();
EnterDiagBlock();
State->EmittedAnyDiagBlocks = true;
}
// Compute the diagnostic text.
State->diagBuf.clear();
Info.FormatDiagnostic(State->diagBuf);
if (Info.getLocation().isInvalid()) {
// Special-case diagnostics with no location. We may not have entered a
// source file in this case, so we can't use the normal DiagnosticsRenderer
// machinery.
// Make sure we bracket all notes as "sub-diagnostics". This matches
// the behavior in SDiagsRenderer::emitDiagnostic().
if (DiagLevel == DiagnosticsEngine::Note)
EnterDiagBlock();
EmitDiagnosticMessage(SourceLocation(), PresumedLoc(), DiagLevel,
State->diagBuf, 0, &Info);
if (DiagLevel == DiagnosticsEngine::Note)
ExitDiagBlock();
return;
}
assert(Info.hasSourceManager() && LangOpts &&
"Unexpected diagnostic with valid location outside of a source file");
SDiagsRenderer Renderer(*this, *LangOpts, &*State->DiagOpts);
Renderer.emitDiagnostic(Info.getLocation(), DiagLevel,
State->diagBuf.str(),
Info.getRanges(),
llvm::makeArrayRef(Info.getFixItHints(),
Info.getNumFixItHints()),
&Info.getSourceManager(),
&Info);
}
/// \brief Print any diagnostic option information to a raw_ostream.
///
/// This implements all of the logic for adding diagnostic options to a message
/// (via OS). Each relevant option is comma separated and all are enclosed in
/// the standard bracketing: " [...]".
static void printDiagnosticOptions(raw_ostream &OS,
DiagnosticsEngine::Level Level,
const Diagnostic &Info,
const DiagnosticOptions &DiagOpts) {
bool Started = false;
if (DiagOpts.ShowOptionNames) {
// Handle special cases for non-warnings early.
if (Info.getID() == diag::fatal_too_many_errors) {
OS << " [-ferror-limit=]";
return;
}
// The code below is somewhat fragile because we are essentially trying to
// report to the user what happened by inferring what the diagnostic engine
// did. Eventually it might make more sense to have the diagnostic engine
// include some "why" information in the diagnostic.
// If this is a warning which has been mapped to an error by the user (as
// inferred by checking whether the default mapping is to an error) then
// flag it as such. Note that diagnostics could also have been mapped by a
// pragma, but we don't currently have a way to distinguish this.
if (Level == DiagnosticsEngine::Error &&
DiagnosticIDs::isBuiltinWarningOrExtension(Info.getID()) &&
!DiagnosticIDs::isDefaultMappingAsError(Info.getID())) {
OS << " [-Werror";
Started = true;
}
StringRef Opt = DiagnosticIDs::getWarningOptionForDiag(Info.getID());
if (!Opt.empty()) {
OS << (Started ? "," : " [")
<< (Level == DiagnosticsEngine::Remark ? "-R" : "-W") << Opt;
StringRef OptValue = Info.getDiags()->getFlagValue();
if (!OptValue.empty())
OS << "=" << OptValue;
Started = true;
}
}
// If the user wants to see category information, include it too.
if (DiagOpts.ShowCategories) {
unsigned DiagCategory =
DiagnosticIDs::getCategoryNumberForDiag(Info.getID());
if (DiagCategory) {
OS << (Started ? "," : " [");
Started = true;
if (DiagOpts.ShowCategories == 1)
OS << DiagCategory;
else {
assert(DiagOpts.ShowCategories == 2 && "Invalid ShowCategories value");
OS << DiagnosticIDs::getCategoryNameFromID(DiagCategory);
}
}
}
if (Started)
OS << ']';
}
ElfSymbol::ElfSymbol(const ElfConfig& config,
const llvm::MemoryBuffer& in,
const ElfSection& symtab_sect,
ElfSymbolIndex index,
Section* sections[],
Diagnostic& diags)
: m_sect(0)
, m_name_index(0)
, m_value(0)
, m_symindex(index)
, m_in_table(true)
, m_weak_ref(false)
, m_weak_refr(false)
{
InputBuffer inbuf(in);
ElfSize symsize = symtab_sect.getEntSize();
inbuf.setPosition(symtab_sect.getFileOffset() + index * symsize);
if (inbuf.getReadableSize() < symsize)
{
diags.Report(SourceLocation(), diag::err_symbol_unreadable);
return;
}
config.setEndian(inbuf);
m_name_index = ReadU32(inbuf);
if (config.cls == ELFCLASS32)
{
m_value = ReadU32(inbuf);
m_size = Expr(ReadU32(inbuf));
}
unsigned char info = ReadU8(inbuf);
m_bind = ELF_ST_BIND(info);
m_type = ELF_ST_TYPE(info);
m_vis = ELF_ST_VISIBILITY(ReadU8(inbuf));
m_index = static_cast<ElfSectionIndex>(ReadU16(inbuf));
if (m_index != SHN_UNDEF && m_index < config.secthead_count)
m_sect = sections[m_index];
if (config.cls == ELFCLASS64)
{
m_value = ReadU64(inbuf);
m_size = Expr(ReadU64(inbuf));
}
}
void
yasm::DirRegister(NameValue& nv,
Diagnostic& diags,
RegisterPtr* out,
bool* out_set)
{
if (!nv.isRegister())
{
diags.Report(nv.getNameSource(), diag::err_value_register)
<< nv.getValueRange();
return;
}
*out = nv.getRegister();
*out_set = true;
}
bool
Multiple::CalcLen(Bytecode& bc,
const Bytecode::AddSpanFunc& add_span,
Diagnostic& diags)
{
// Calculate multiple value as an integer
m_int = 1;
if (m_expr.isIntNum())
{
IntNum num = m_expr.getIntNum();
if (num.getSign() < 0)
{
m_int = 0;
diags.Report(bc.getSource(), diag::err_multiple_negative);
return false;
}
else
m_int = num.getInt();
}
else
{
if (m_expr.Contains(ExprTerm::FLOAT))
{
m_int = 0;
diags.Report(bc.getSource(), diag::err_expr_contains_float);
return false;
}
else
{
Value value(0, Expr::Ptr(m_expr.clone()));
add_span(bc, 0, value, 0, 0);
m_int = 0; // assume 0 to start
}
}
return true;
}
void
yasm::DirString(NameValue& nv,
Diagnostic& diags,
std::string* out,
bool* out_set)
{
if (!nv.isString())
{
diags.Report(nv.getNameSource(), diag::err_value_string_or_id)
<< nv.getValueRange();
return;
}
*out = nv.getString();
*out_set = true;
}
