SourceLocation ClangAsmParserCallback::translateLocation(const llvm::SourceMgr &LSM, llvm::SMLoc SMLoc) { // Compute an offset into the inline asm buffer. // FIXME: This isn't right if .macro is involved (but hopefully, no // real-world code does that). const llvm::MemoryBuffer *LBuf = LSM.getMemoryBuffer(LSM.FindBufferContainingLoc(SMLoc)); unsigned Offset = SMLoc.getPointer() - LBuf->getBufferStart(); // Figure out which token that offset points into. const unsigned *TokOffsetPtr = std::lower_bound(AsmTokOffsets.begin(), AsmTokOffsets.end(), Offset); unsigned TokIndex = TokOffsetPtr - AsmTokOffsets.begin(); unsigned TokOffset = *TokOffsetPtr; // If we come up with an answer which seems sane, use it; otherwise, // just point at the __asm keyword. // FIXME: Assert the answer is sane once we handle .macro correctly. SourceLocation Loc = AsmLoc; if (TokIndex < AsmToks.size()) { const Token &Tok = AsmToks[TokIndex]; Loc = Tok.getLocation(); Loc = Loc.getLocWithOffset(Offset - TokOffset); } return Loc; }
bool add_source(string file) { L(cout << "### Adding file " << file << endl); std::string full_path; unsigned bufn = sm.AddIncludeFile(file, llvm::SMLoc(), full_path); if (bufn == ~0U) { cerr << "*** Could not load file " << file << ". Please check that you have spelled the interface name correctly and specified all include paths." << endl; return false; } L(cout << "### Parsing file " << file << endl); parser_t* parser = new parser_t(sm, verbose); L(cout << "### Initing parser" << endl); parser->init(sm.getMemoryBuffer(bufn)); L(cout << "### Adding parser to stack" << endl); parser_stack.push_back(parser); return true; }
/// CheckLists - Compare expected to seen diagnostic lists and return the /// the difference between them. /// static unsigned CheckLists(DiagnosticsEngine &Diags, const llvm::SourceMgr &SourceMgr, DiagnosticsEngine::Level Label, DirectiveList &Left, const_diag_iterator d2_begin, const_diag_iterator d2_end) { DirectiveList LeftOnly; DiagList Right(d2_begin, d2_end); for (DirectiveList::iterator I = Left.begin(), E = Left.end(); I != E; ++I) { Directive& D = **I; unsigned LineNo1 = SourceMgr.FindLineNumber(D.DiagnosticLoc); for (unsigned i = 0; i < D.Max; ++i) { DiagList::iterator II, IE; for (II = Right.begin(), IE = Right.end(); II != IE; ++II) { unsigned LineNo2 = SourceMgr.FindLineNumber(II->first); if (LineNo1 != LineNo2) continue; if (!IsFromSameFile(SourceMgr, D.DiagnosticLoc, II->first)) continue; const std::string &RightText = II->second; if (D.match(RightText)) break; } if (II == IE) { // Not found. if (i >= D.Min) break; LeftOnly.push_back(*I); } else { // Found. The same cannot be found twice. Right.erase(II); } } } // Now all that's left in Right are those that were not matched. unsigned num = PrintExpected(Diags, SourceMgr, LeftOnly, Label); num += PrintUnexpected(Diags, &SourceMgr, Right.begin(), Right.end(), Label); return num; }
/// \brief Takes a list of diagnostics that were expected to have been generated /// but were not and produces a diagnostic to the user from this. static unsigned PrintExpected(DiagnosticsEngine &Diags, llvm::SourceMgr &SourceMgr, DirectiveList &DL, const char *Kind) { if (DL.empty()) return 0; SmallString<256> Fmt; llvm::raw_svector_ostream OS(Fmt); for (DirectiveList::iterator I = DL.begin(), E = DL.end(); I != E; ++I) { Directive &D = **I; OS << "\n Line " << SourceMgr.getLineAndColumn(D.DiagnosticLoc).first; if (D.DirectiveLoc != D.DiagnosticLoc) { int BufID = SourceMgr.FindBufferContainingLoc(D.DirectiveLoc); OS << " (directive at " << SourceMgr.getMemoryBuffer(BufID)->getBufferIdentifier() << SourceMgr.getLineAndColumn(D.DirectiveLoc).first << ")"; } OS << ": " << D.Text; } Diags.Report(SourceLocation(), diag::verify_inconsistent_diags) << Kind << /*Unexpected=*/false << OS.str(); return DL.size(); }
/// \brief Get the source location in \arg BufferId for the given line. static SourceLocation translateLine(const llvm::SourceMgr &SM, int BufferId, unsigned Line) { const llvm::MemoryBuffer *Buffer = SM.getMemoryBuffer(BufferId); const char *Buf = Buffer->getBufferStart(); size_t BufLength = Buffer->getBufferSize(); if (BufLength == 0) return SourceLocation::getFromPointer(Buf); size_t i = 0; unsigned LineNo = 1; for (; i < BufLength && LineNo != Line; ++i) if (Buf[i] == '\n') ++LineNo; return SourceLocation::getFromPointer(Buf + i); }
/// Go through the comment and see if it indicates expected /// diagnostics. If so, then put them in the appropriate directive list. /// /// Returns true if any valid directives were found. static bool ParseDirective(StringRef S, ExpectedData *ED, const llvm::SourceMgr &SM, SourceLocation Pos, DiagnosticsEngine &Diags, VerifyDiagnosticConsumer::DirectiveStatus &Status) { // A single comment may contain multiple directives. bool FoundDirective = false; for (ParseHelper PH(S); !PH.Done();) { // Search for token: expected if (!PH.Search("expected", true)) break; PH.Advance(); // Next token: - if (!PH.Next("-")) continue; PH.Advance(); // Next token: { error | warning | note } DirectiveList* DL = NULL; if (PH.Next("diag")) DL = ED ? &ED->Errors : NULL; else if (PH.Next("note")) DL = ED ? &ED->Notes : NULL; else if (PH.Next("no-diagnostics")) { if (Status == VerifyDiagnosticConsumer::HasOtherExpectedDirectives) Diags.Report(Pos, diag::verify_invalid_no_diags) << /*IsExpectedNoDiagnostics=*/true; else Status = VerifyDiagnosticConsumer::HasExpectedNoDiagnostics; continue; } else continue; PH.Advance(); if (Status == VerifyDiagnosticConsumer::HasExpectedNoDiagnostics) { Diags.Report(Pos, diag::verify_invalid_no_diags) << /*IsExpectedNoDiagnostics=*/false; continue; } Status = VerifyDiagnosticConsumer::HasOtherExpectedDirectives; // If a directive has been found but we're not interested // in storing the directive information, return now. if (!DL) return true; // Default directive kind. bool RegexKind = false; const char* KindStr = "string"; // Next optional token: - if (PH.Next("-re")) { PH.Advance(); RegexKind = true; KindStr = "regex"; } // Next optional token: @ SourceLocation ExpectedLoc; if (!PH.Next("@")) { ExpectedLoc = Pos; } else { PH.Advance(); unsigned Line = 0; bool FoundPlus = PH.Next("+"); if (FoundPlus || PH.Next("-")) { // Relative to current line. PH.Advance(); unsigned ExpectedLine = SM.getLineAndColumn(Pos).first; if (PH.Next(Line) && (FoundPlus || Line < ExpectedLine)) { if (FoundPlus) ExpectedLine += Line; else ExpectedLine -= Line; ExpectedLoc = locForLine(SM, Pos, ExpectedLine); } } else { // Absolute line number. if (PH.Next(Line) && Line > 0) ExpectedLoc = locForLine(SM, Pos, Line); } if (!ExpectedLoc.isValid()) { Diags.Report(Pos, diag::verify_missing_line) << KindStr; continue; } PH.Advance(); } // Skip optional whitespace. PH.SkipWhitespace(); // Next optional token: positive integer or a '+'. unsigned Min = 1; unsigned Max = 1; if (PH.Next(Min)) { PH.Advance(); // A positive integer can be followed by a '+' meaning min // or more, or by a '-' meaning a range from min to max. if (PH.Next("+")) { Max = Directive::MaxCount; PH.Advance(); } else if (PH.Next("-")) { PH.Advance(); if (!PH.Next(Max) || Max < Min) { Diags.Report(Pos, diag::verify_invalid_range) << KindStr; continue; } PH.Advance(); } else { Max = Min; } } else if (PH.Next("+")) { // '+' on its own means "1 or more". Max = Directive::MaxCount; PH.Advance(); } // Skip optional whitespace. PH.SkipWhitespace(); // Next token: {{ if (!PH.Next("{{")) { Diags.Report(Pos, diag::verify_missing_start) << KindStr; continue; } PH.Advance(); const char* const ContentBegin = PH.C; // mark content begin // Search for token: }} if (!PH.Search("}}")) { Diags.Report(Pos, diag::verify_missing_end) << KindStr; continue; } const char* const ContentEnd = PH.P; // mark content end PH.Advance(); // Build directive text; convert \n to newlines. std::string Text; StringRef NewlineStr = "\\n"; StringRef Content(ContentBegin, ContentEnd-ContentBegin); size_t CPos = 0; size_t FPos; while ((FPos = Content.find(NewlineStr, CPos)) != StringRef::npos) { Text += Content.substr(CPos, FPos-CPos); Text += '\n'; CPos = FPos + NewlineStr.size(); } if (Text.empty()) Text.assign(ContentBegin, ContentEnd); // Construct new directive. Directive *D = Directive::create(RegexKind, Pos, ExpectedLoc, Text, Min, Max); std::string Error; if (D->isValid(Error)) { DL->push_back(D); FoundDirective = true; } else { Diags.Report(Pos, diag::verify_invalid_content) << KindStr << Error; } } return FoundDirective; }
void BuildSystemInvocation::parse(llvm::ArrayRef<std::string> args, llvm::SourceMgr& sourceMgr) { auto error = [&](const Twine &message) { sourceMgr.PrintMessage(llvm::SMLoc{}, llvm::SourceMgr::DK_Error, message); hadErrors = true; }; while (!args.empty()) { const auto& option = args.front(); args = args.slice(1); if (option == "-") { for (const auto& arg: args) { positionalArgs.push_back(arg); } break; } if (!option.empty() && option[0] != '-') { positionalArgs.push_back(option); continue; } if (option == "--help") { showUsage = true; break; } else if (option == "--version") { showVersion = true; break; } else if (option == "--no-db") { dbPath = ""; } else if (option == "--db") { if (args.empty()) { error("missing argument to '" + option + "'"); break; } dbPath = args[0]; args = args.slice(1); } else if (option == "-C" || option == "--chdir") { if (args.empty()) { error("missing argument to '" + option + "'"); break; } chdirPath = args[0]; args = args.slice(1); } else if (option == "-f") { if (args.empty()) { error("missing argument to '" + option + "'"); break; } buildFilePath = args[0]; args = args.slice(1); } else if (option == "--serial") { useSerialBuild = true; } else if (option == "-v" || option == "--verbose") { showVerboseStatus = true; } else if (option == "--trace") { if (args.empty()) { error("missing argument to '" + option + "'"); break; } traceFilePath = args[0]; args = args.slice(1); } else { error("invalid option '" + option + "'"); break; } } }
/// \brief Determine whether two source locations come from the same file. static bool IsFromSameFile(const llvm::SourceMgr &SM, SourceLocation DirectiveLoc, SourceLocation DiagnosticLoc) { return SM.FindBufferContainingLoc(DirectiveLoc) == SM.FindBufferContainingLoc(DiagnosticLoc); return true; }
void set_include_dirs(vector<string> dirs) { include_dirs = dirs; sm.setIncludeDirs(include_dirs); }