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