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; }