miyuki updated this revision to Diff 325762.
miyuki edited the summary of this revision.
miyuki added a comment.
Fixed python bindings and formatting.
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D97204/new/
https://reviews.llvm.org/D97204
Files:
clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp
clang/CMakeLists.txt
clang/bindings/python/clang/cindex.py
clang/include/clang-c/Index.h
clang/include/clang/AST/DeclBase.h
clang/include/clang/AST/DeclarationName.h
clang/include/clang/AST/Stmt.h
clang/include/clang/Analysis/ProgramPoint.h
clang/include/clang/Basic/SourceLocation.h
clang/include/clang/Basic/SourceManager.h
clang/include/clang/Lex/Preprocessor.h
clang/include/clang/Lex/Token.h
clang/include/clang/Serialization/ASTBitCodes.h
clang/include/clang/Serialization/ASTReader.h
clang/include/clang/Serialization/ASTWriter.h
clang/include/clang/Serialization/ModuleFile.h
clang/lib/ARCMigrate/TransEmptyStatementsAndDealloc.cpp
clang/lib/AST/NestedNameSpecifier.cpp
clang/lib/AST/SelectorLocationsKind.cpp
clang/lib/Basic/SourceLocation.cpp
clang/lib/Basic/SourceManager.cpp
clang/lib/CodeGen/CGOpenMPRuntime.cpp
clang/lib/CodeGen/CGStmt.cpp
clang/lib/CodeGen/CodeGenAction.cpp
clang/lib/CodeGen/CoverageMappingGen.cpp
clang/lib/Format/FormatTokenLexer.cpp
clang/lib/Lex/Lexer.cpp
clang/lib/Lex/ModuleMap.cpp
clang/lib/Lex/PPCaching.cpp
clang/lib/Lex/TokenLexer.cpp
clang/lib/Parse/ParseStmtAsm.cpp
clang/lib/Serialization/ASTReader.cpp
clang/lib/Serialization/ASTWriter.cpp
clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp
clang/test/CMakeLists.txt
clang/test/Lexer/SourceLocationsOverflow.c
clang/test/lit.cfg.py
clang/test/lit.site.cfg.py.in
clang/tools/libclang/CIndex.cpp
llvm/include/llvm/IR/DiagnosticInfo.h
llvm/include/llvm/IR/LLVMContext.h
llvm/include/llvm/MC/MCParser/MCAsmParser.h
llvm/lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp
llvm/lib/CodeGen/MachineInstr.cpp
llvm/lib/IR/LLVMContext.cpp
llvm/lib/MC/MCParser/AsmParser.cpp
llvm/lib/MC/MCParser/MasmParser.cpp
llvm/tools/llc/llc.cpp
Index: llvm/tools/llc/llc.cpp
===================================================================
--- llvm/tools/llc/llc.cpp
+++ llvm/tools/llc/llc.cpp
@@ -306,7 +306,7 @@
};
static void InlineAsmDiagHandler(const SMDiagnostic &SMD, void *Context,
- unsigned LocCookie) {
+ uint64_t LocCookie) {
bool *HasError = static_cast<bool *>(Context);
if (SMD.getKind() == SourceMgr::DK_Error)
*HasError = true;
Index: llvm/lib/MC/MCParser/MasmParser.cpp
===================================================================
--- llvm/lib/MC/MCParser/MasmParser.cpp
+++ llvm/lib/MC/MCParser/MasmParser.cpp
@@ -509,9 +509,9 @@
bool lookUpType(StringRef Name, AsmTypeInfo &Info) const override;
- bool parseMSInlineAsm(void *AsmLoc, std::string &AsmString,
+ bool parseMSInlineAsm(uint64_t AsmLoc, std::string &AsmString,
unsigned &NumOutputs, unsigned &NumInputs,
- SmallVectorImpl<std::pair<void *,bool>> &OpDecls,
+ SmallVectorImpl<std::pair<void *, bool>> &OpDecls,
SmallVectorImpl<std::string> &Constraints,
SmallVectorImpl<std::string> &Clobbers,
const MCInstrInfo *MII, const MCInstPrinter *IP,
@@ -7021,7 +7021,7 @@
}
bool MasmParser::parseMSInlineAsm(
- void *AsmLoc, std::string &AsmString, unsigned &NumOutputs,
+ uint64_t AsmLoc, std::string &AsmString, unsigned &NumOutputs,
unsigned &NumInputs, SmallVectorImpl<std::pair<void *, bool>> &OpDecls,
SmallVectorImpl<std::string> &Constraints,
SmallVectorImpl<std::string> &Clobbers, const MCInstrInfo *MII,
Index: llvm/lib/MC/MCParser/AsmParser.cpp
===================================================================
--- llvm/lib/MC/MCParser/AsmParser.cpp
+++ llvm/lib/MC/MCParser/AsmParser.cpp
@@ -235,9 +235,9 @@
}
bool isParsingMSInlineAsm() override { return ParsingMSInlineAsm; }
- bool parseMSInlineAsm(void *AsmLoc, std::string &AsmString,
+ bool parseMSInlineAsm(uint64_t AsmLoc, std::string &AsmString,
unsigned &NumOutputs, unsigned &NumInputs,
- SmallVectorImpl<std::pair<void *,bool>> &OpDecls,
+ SmallVectorImpl<std::pair<void *, bool>> &OpDecls,
SmallVectorImpl<std::string> &Constraints,
SmallVectorImpl<std::string> &Clobbers,
const MCInstrInfo *MII, const MCInstPrinter *IP,
@@ -5879,7 +5879,7 @@
}
bool AsmParser::parseMSInlineAsm(
- void *AsmLoc, std::string &AsmString, unsigned &NumOutputs,
+ uint64_t AsmLoc, std::string &AsmString, unsigned &NumOutputs,
unsigned &NumInputs, SmallVectorImpl<std::pair<void *, bool>> &OpDecls,
SmallVectorImpl<std::string> &Constraints,
SmallVectorImpl<std::string> &Clobbers, const MCInstrInfo *MII,
Index: llvm/lib/IR/LLVMContext.cpp
===================================================================
--- llvm/lib/IR/LLVMContext.cpp
+++ llvm/lib/IR/LLVMContext.cpp
@@ -268,7 +268,7 @@
exit(1);
}
-void LLVMContext::emitError(unsigned LocCookie, const Twine &ErrorStr) {
+void LLVMContext::emitError(uint64_t LocCookie, const Twine &ErrorStr) {
diagnose(DiagnosticInfoInlineAsm(LocCookie, ErrorStr));
}
Index: llvm/lib/CodeGen/MachineInstr.cpp
===================================================================
--- llvm/lib/CodeGen/MachineInstr.cpp
+++ llvm/lib/CodeGen/MachineInstr.cpp
@@ -2078,7 +2078,7 @@
void MachineInstr::emitError(StringRef Msg) const {
// Find the source location cookie.
- unsigned LocCookie = 0;
+ uint64_t LocCookie = 0;
const MDNode *LocMD = nullptr;
for (unsigned i = getNumOperands(); i != 0; --i) {
if (getOperand(i-1).isMetadata() &&
Index: llvm/lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp
===================================================================
--- llvm/lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp
+++ llvm/lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp
@@ -172,7 +172,7 @@
static void EmitMSInlineAsmStr(const char *AsmStr, const MachineInstr *MI,
MachineModuleInfo *MMI, AsmPrinter *AP,
- unsigned LocCookie, raw_ostream &OS) {
+ uint64_t LocCookie, raw_ostream &OS) {
// Switch to the inline assembly variant.
OS << "\t.intel_syntax\n\t";
@@ -314,7 +314,7 @@
static void EmitGCCInlineAsmStr(const char *AsmStr, const MachineInstr *MI,
MachineModuleInfo *MMI, int AsmPrinterVariant,
- AsmPrinter *AP, unsigned LocCookie,
+ AsmPrinter *AP, uint64_t LocCookie,
raw_ostream &OS) {
int CurVariant = -1; // The number of the {.|.|.} region we are in.
const char *LastEmitted = AsmStr; // One past the last character emitted.
@@ -523,7 +523,7 @@
// Get the !srcloc metadata node if we have it, and decode the loc cookie from
// it.
- unsigned LocCookie = 0;
+ uint64_t LocCookie = 0;
const MDNode *LocMD = nullptr;
for (unsigned i = MI->getNumOperands(); i != 0; --i) {
if (MI->getOperand(i-1).isMetadata() &&
Index: llvm/include/llvm/MC/MCParser/MCAsmParser.h
===================================================================
--- llvm/include/llvm/MC/MCParser/MCAsmParser.h
+++ llvm/include/llvm/MC/MCParser/MCAsmParser.h
@@ -200,7 +200,7 @@
/// Parse MS-style inline assembly.
virtual bool parseMSInlineAsm(
- void *AsmLoc, std::string &AsmString, unsigned &NumOutputs,
+ uint64_t AsmLoc, std::string &AsmString, unsigned &NumOutputs,
unsigned &NumInputs, SmallVectorImpl<std::pair<void *, bool>> &OpDecls,
SmallVectorImpl<std::string> &Constraints,
SmallVectorImpl<std::string> &Clobbers, const MCInstrInfo *MII,
Index: llvm/include/llvm/IR/LLVMContext.h
===================================================================
--- llvm/include/llvm/IR/LLVMContext.h
+++ llvm/include/llvm/IR/LLVMContext.h
@@ -153,8 +153,8 @@
void enableDebugTypeODRUniquing();
void disableDebugTypeODRUniquing();
- using InlineAsmDiagHandlerTy = void (*)(const SMDiagnostic&, void *Context,
- unsigned LocCookie);
+ using InlineAsmDiagHandlerTy = void (*)(const SMDiagnostic &, void *Context,
+ uint64_t LocCookie);
/// Defines the type of a yield callback.
/// \see LLVMContext::setYieldCallback.
@@ -311,7 +311,7 @@
/// be prepared to drop the erroneous construct on the floor and "not crash".
/// The generated code need not be correct. The error message will be
/// implicitly prefixed with "error: " and should not end with a ".".
- void emitError(unsigned LocCookie, const Twine &ErrorStr);
+ void emitError(uint64_t LocCookie, const Twine &ErrorStr);
void emitError(const Instruction *I, const Twine &ErrorStr);
void emitError(const Twine &ErrorStr);
Index: llvm/include/llvm/IR/DiagnosticInfo.h
===================================================================
--- llvm/include/llvm/IR/DiagnosticInfo.h
+++ llvm/include/llvm/IR/DiagnosticInfo.h
@@ -130,7 +130,7 @@
class DiagnosticInfoInlineAsm : public DiagnosticInfo {
private:
/// Optional line information. 0 if not set.
- unsigned LocCookie = 0;
+ uint64_t LocCookie = 0;
/// Message to be reported.
const Twine &MsgStr;
/// Optional origin of the problem.
@@ -148,7 +148,7 @@
/// \p MsgStr gives the message.
/// This class does not copy \p MsgStr, therefore the reference must be valid
/// for the whole life time of the Diagnostic.
- DiagnosticInfoInlineAsm(unsigned LocCookie, const Twine &MsgStr,
+ DiagnosticInfoInlineAsm(uint64_t LocCookie, const Twine &MsgStr,
DiagnosticSeverity Severity = DS_Error)
: DiagnosticInfo(DK_InlineAsm, Severity), LocCookie(LocCookie),
MsgStr(MsgStr) {}
@@ -161,7 +161,7 @@
DiagnosticInfoInlineAsm(const Instruction &I, const Twine &MsgStr,
DiagnosticSeverity Severity = DS_Error);
- unsigned getLocCookie() const { return LocCookie; }
+ uint64_t getLocCookie() const { return LocCookie; }
const Twine &getMsgStr() const { return MsgStr; }
const Instruction *getInstruction() const { return Instr; }
Index: clang/tools/libclang/CIndex.cpp
===================================================================
--- clang/tools/libclang/CIndex.cpp
+++ clang/tools/libclang/CIndex.cpp
@@ -1982,7 +1982,8 @@
return static_cast<const FieldDecl *>(data[0]);
}
SourceLocation getLoc() const {
- return SourceLocation::getFromRawEncoding((unsigned)(uintptr_t)data[1]);
+ return SourceLocation::getFromRawEncoding(
+ (SourceLocation::UIntType)(uintptr_t)data[1]);
}
};
class EnqueueVisitor : public ConstStmtVisitor<EnqueueVisitor, void> {
@@ -6748,15 +6749,15 @@
//===----------------------------------------------------------------------===//
/* CXToken layout:
- * int_data[0]: a CXTokenKind
- * int_data[1]: starting token location
- * int_data[2]: token length
- * int_data[3]: reserved
+ * uint_data[0]: a CXTokenKind
+ * uint_data[1]: token length
+ * ulint_data[0]: starting token location
+ * ulint_data[1]: reserved
* ptr_data: for identifiers and keywords, an IdentifierInfo*.
* otherwise unused.
*/
CXTokenKind clang_getTokenKind(CXToken CXTok) {
- return static_cast<CXTokenKind>(CXTok.int_data[0]);
+ return static_cast<CXTokenKind>(CXTok.uint_data[0]);
}
CXString clang_getTokenSpelling(CXTranslationUnit TU, CXToken CXTok) {
@@ -6770,7 +6771,7 @@
case CXToken_Literal: {
// We have stashed the starting pointer in the ptr_data field. Use it.
const char *Text = static_cast<const char *>(CXTok.ptr_data);
- return cxstring::createDup(StringRef(Text, CXTok.int_data[2]));
+ return cxstring::createDup(StringRef(Text, CXTok.uint_data[1]));
}
case CXToken_Punctuation:
@@ -6789,7 +6790,7 @@
if (!CXXUnit)
return cxstring::createEmpty();
- SourceLocation Loc = SourceLocation::getFromRawEncoding(CXTok.int_data[1]);
+ SourceLocation Loc = SourceLocation::getFromRawEncoding(CXTok.ulint_data[0]);
std::pair<FileID, unsigned> LocInfo =
CXXUnit->getSourceManager().getDecomposedSpellingLoc(Loc);
bool Invalid = false;
@@ -6798,7 +6799,7 @@
if (Invalid)
return cxstring::createEmpty();
- return cxstring::createDup(Buffer.substr(LocInfo.second, CXTok.int_data[2]));
+ return cxstring::createDup(Buffer.substr(LocInfo.second, CXTok.uint_data[1]));
}
CXSourceLocation clang_getTokenLocation(CXTranslationUnit TU, CXToken CXTok) {
@@ -6813,7 +6814,7 @@
return cxloc::translateSourceLocation(
CXXUnit->getASTContext(),
- SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
+ SourceLocation::getFromRawEncoding(CXTok.ulint_data[0]));
}
CXSourceRange clang_getTokenExtent(CXTranslationUnit TU, CXToken CXTok) {
@@ -6828,7 +6829,7 @@
return cxloc::translateSourceRange(
CXXUnit->getASTContext(),
- SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
+ SourceLocation::getFromRawEncoding(CXTok.ulint_data[0]));
}
static void getTokens(ASTUnit *CXXUnit, SourceRange Range,
@@ -6868,30 +6869,30 @@
CXToken CXTok;
// - Common fields
- CXTok.int_data[1] = Tok.getLocation().getRawEncoding();
- CXTok.int_data[2] = Tok.getLength();
- CXTok.int_data[3] = 0;
+ CXTok.uint_data[1] = Tok.getLength();
+ CXTok.ulint_data[0] = Tok.getLocation().getRawEncoding();
+ CXTok.ulint_data[1] = 0;
// - Kind-specific fields
if (Tok.isLiteral()) {
- CXTok.int_data[0] = CXToken_Literal;
+ CXTok.uint_data[0] = CXToken_Literal;
CXTok.ptr_data = const_cast<char *>(Tok.getLiteralData());
} else if (Tok.is(tok::raw_identifier)) {
// Lookup the identifier to determine whether we have a keyword.
IdentifierInfo *II = CXXUnit->getPreprocessor().LookUpIdentifierInfo(Tok);
if ((II->getObjCKeywordID() != tok::objc_not_keyword) && previousWasAt) {
- CXTok.int_data[0] = CXToken_Keyword;
+ CXTok.uint_data[0] = CXToken_Keyword;
} else {
- CXTok.int_data[0] =
+ CXTok.uint_data[0] =
Tok.is(tok::identifier) ? CXToken_Identifier : CXToken_Keyword;
}
CXTok.ptr_data = II;
} else if (Tok.is(tok::comment)) {
- CXTok.int_data[0] = CXToken_Comment;
+ CXTok.uint_data[0] = CXToken_Comment;
CXTok.ptr_data = nullptr;
} else {
- CXTok.int_data[0] = CXToken_Punctuation;
+ CXTok.uint_data[0] = CXToken_Punctuation;
CXTok.ptr_data = nullptr;
}
CXTokens.push_back(CXTok);
@@ -7024,13 +7025,13 @@
unsigned NextToken() const { return TokIdx; }
void AdvanceToken() { ++TokIdx; }
SourceLocation GetTokenLoc(unsigned tokI) {
- return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[1]);
+ return SourceLocation::getFromRawEncoding(getTok(tokI).ulint_data[0]);
}
bool isFunctionMacroToken(unsigned tokI) const {
- return getTok(tokI).int_data[3] != 0;
+ return getTok(tokI).ulint_data[1] != 0;
}
SourceLocation getFunctionMacroTokenLoc(unsigned tokI) const {
- return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[3]);
+ return SourceLocation::getFromRawEncoding(getTok(tokI).ulint_data[1]);
}
void annotateAndAdvanceTokens(CXCursor, RangeComparisonResult, SourceRange);
@@ -7525,13 +7526,13 @@
}
SourceLocation getTokenLoc(unsigned tokI) {
- return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[1]);
+ return SourceLocation::getFromRawEncoding(getTok(tokI).ulint_data[0]);
}
void setFunctionMacroTokenLoc(unsigned tokI, SourceLocation loc) {
- // The third field is reserved and currently not used. Use it here
+ // The second long int field is reserved and currently not used. Use it here
// to mark macro arg expanded tokens with their expanded locations.
- getTok(tokI).int_data[3] = loc.getRawEncoding();
+ getTok(tokI).ulint_data[1] = loc.getRawEncoding();
}
};
@@ -7592,7 +7593,7 @@
break;
unsigned TokIdx = NextIdx - 1;
assert(Tok.getLocation() ==
- SourceLocation::getFromRawEncoding(Tokens[TokIdx].int_data[1]));
+ SourceLocation::getFromRawEncoding(Tokens[TokIdx].ulint_data[0]));
reprocess:
if (Tok.is(tok::hash) && Tok.isAtStartOfLine()) {
@@ -7643,7 +7644,7 @@
unsigned LastIdx = finished ? NextIdx - 1 : NextIdx - 2;
assert(TokIdx <= LastIdx);
SourceLocation EndLoc =
- SourceLocation::getFromRawEncoding(Tokens[LastIdx].int_data[1]);
+ SourceLocation::getFromRawEncoding(Tokens[LastIdx].ulint_data[0]);
CXCursor Cursor =
MakePreprocessingDirectiveCursor(SourceRange(BeginLoc, EndLoc), TU);
@@ -7735,7 +7736,7 @@
.Case("weak", true)
.Case("class", true)
.Default(false))
- Tokens[I].int_data[0] = CXToken_Keyword;
+ Tokens[I].uint_data[0] = CXToken_Keyword;
}
continue;
}
@@ -7751,13 +7752,13 @@
.Case("bycopy", true)
.Case("byref", true)
.Default(false))
- Tokens[I].int_data[0] = CXToken_Keyword;
+ Tokens[I].uint_data[0] = CXToken_Keyword;
continue;
}
if (Cursors[I].kind == CXCursor_CXXFinalAttr ||
Cursors[I].kind == CXCursor_CXXOverrideAttr) {
- Tokens[I].int_data[0] = CXToken_Keyword;
+ Tokens[I].uint_data[0] = CXToken_Keyword;
continue;
}
}
Index: clang/test/lit.site.cfg.py.in
===================================================================
--- clang/test/lit.site.cfg.py.in
+++ clang/test/lit.site.cfg.py.in
@@ -22,6 +22,7 @@
config.clang_staticanalyzer = @CLANG_ENABLE_STATIC_ANALYZER@
config.clang_staticanalyzer_z3 = "@LLVM_WITH_Z3@"
config.clang_examples = @CLANG_BUILD_EXAMPLES@
+config.clang_64_bit_source_locations = @CLANG_64_BIT_SOURCE_LOCATIONS@
config.enable_shared = @ENABLE_SHARED@
config.enable_backtrace = @ENABLE_BACKTRACES@
config.enable_experimental_new_pass_manager = @LLVM_ENABLE_NEW_PASS_MANAGER@
Index: clang/test/lit.cfg.py
===================================================================
--- clang/test/lit.cfg.py
+++ clang/test/lit.cfg.py
@@ -197,6 +197,9 @@
if config.enable_threads:
config.available_features.add('thread_support')
+if config.clang_64_bit_source_locations:
+ config.available_features.add('clang-64-bit-source-locations')
+
# Check if we should allow outputs to console.
run_console_tests = int(lit_config.params.get('enable_console', '0'))
if run_console_tests != 0:
Index: clang/test/Lexer/SourceLocationsOverflow.c
===================================================================
--- clang/test/Lexer/SourceLocationsOverflow.c
+++ clang/test/Lexer/SourceLocationsOverflow.c
@@ -1,4 +1,6 @@
// RUN: not %clang %s -S -o - 2>&1 | FileCheck %s
+// UNSUPPORTED: clang-64-bit-source-locations
+
// CHECK: In file included from {{.*}}SourceLocationsOverflow.c
// CHECK-NEXT: inc1.h{{.*}}: fatal error: sorry, this include generates a translation unit too large for Clang to process.
// CHECK-NEXT: #include "inc2.h"
Index: clang/test/CMakeLists.txt
===================================================================
--- clang/test/CMakeLists.txt
+++ clang/test/CMakeLists.txt
@@ -14,6 +14,7 @@
CLANG_ENABLE_ARCMT
CLANG_ENABLE_STATIC_ANALYZER
CLANG_SPAWN_CC1
+ CLANG_64_BIT_SOURCE_LOCATIONS
ENABLE_BACKTRACES
LLVM_ENABLE_NEW_PASS_MANAGER
LLVM_ENABLE_ZLIB
Index: clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp
===================================================================
--- clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp
+++ clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp
@@ -1082,7 +1082,7 @@
// selected range.
SourceLocation E =
- InstantiationEnd.getLocWithOffset(EndColNo - OldEndColNo);
+ InstantiationEnd.getLocWithOffset((int)(EndColNo - OldEndColNo));
html::HighlightRange(R, InstantiationStart, E, HighlightStart, HighlightEnd);
}
Index: clang/lib/Serialization/ASTWriter.cpp
===================================================================
--- clang/lib/Serialization/ASTWriter.cpp
+++ clang/lib/Serialization/ASTWriter.cpp
@@ -2041,7 +2041,7 @@
Record.push_back(Expansion.isExpansionTokenRange());
// Compute the token length for this macro expansion.
- unsigned NextOffset = SourceMgr.getNextLocalOffset();
+ SourceLocation::UIntType NextOffset = SourceMgr.getNextLocalOffset();
if (I + 1 != N)
NextOffset = SourceMgr.getLocalSLocEntry(I + 1).getOffset();
Record.push_back(NextOffset - SLoc->getOffset() - 1);
@@ -4672,7 +4672,7 @@
// The map consists solely of a blob with the following format:
// *(module-kind:i8
// module-name-len:i16 module-name:len*i8
- // source-location-offset:i32
+ // source-location-offset:i32/i64
// identifier-id:i32
// preprocessed-entity-id:i32
// macro-definition-id:i32
@@ -4701,16 +4701,20 @@
LE.write<uint16_t>(Name.size());
Out.write(Name.data(), Name.size());
- // Note: if a base ID was uint max, it would not be possible to load
- // another module after it or have more than one entity inside it.
- uint32_t None = std::numeric_limits<uint32_t>::max();
-
- auto writeBaseIDOrNone = [&](uint32_t BaseID, bool ShouldWrite) {
- assert(BaseID < std::numeric_limits<uint32_t>::max() && "base id too high");
+ auto writeBaseIDOrNone = [&](auto BaseID, bool ShouldWrite) {
+ using T = decltype(BaseID);
+ static_assert(std::is_same<T, uint32_t>::value ||
+ std::is_same<T, uint64_t>::value,
+ "Invalid BaseID type");
+ assert(BaseID < std::numeric_limits<T>::max() && "base id too high");
if (ShouldWrite)
- LE.write<uint32_t>(BaseID);
- else
- LE.write<uint32_t>(None);
+ LE.write<T>(BaseID);
+ else {
+ // Note: if a base ID was uint max, it would not be possible to load
+ // another module after it or have more than one entity inside it.
+ constexpr T None = std::numeric_limits<T>::max();
+ LE.write<T>(None);
+ }
};
// These values should be unique within a chain, since they will be read
@@ -5097,8 +5101,8 @@
}
void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) {
- uint32_t Raw = Loc.getRawEncoding();
- Record.push_back((Raw << 1) | (Raw >> 31));
+ SourceLocation::UIntType Raw = Loc.getRawEncoding();
+ Record.push_back((Raw << 1) | (Raw >> (8 * sizeof(Raw) - 1)));
}
void ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &Record) {
Index: clang/lib/Serialization/ASTReader.cpp
===================================================================
--- clang/lib/Serialization/ASTReader.cpp
+++ clang/lib/Serialization/ASTReader.cpp
@@ -1480,7 +1480,7 @@
}
BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
- unsigned BaseOffset = F->SLocEntryBaseOffset;
+ SourceLocation::UIntType BaseOffset = F->SLocEntryBaseOffset;
++NumSLocEntriesRead;
Expected<llvm::BitstreamEntry> MaybeEntry = SLocEntryCursor.advance();
@@ -3403,7 +3403,7 @@
case SOURCE_LOCATION_OFFSETS: {
F.SLocEntryOffsets = (const uint32_t *)Blob.data();
F.LocalNumSLocEntries = Record[0];
- unsigned SLocSpaceSize = Record[1];
+ SourceLocation::UIntType SLocSpaceSize = Record[1];
F.SLocEntryOffsetsBase = Record[2] + F.SourceManagerBlockStartOffset;
std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
@@ -3421,7 +3421,7 @@
F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
// SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
- assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
+ assert((F.SLocEntryBaseOffset & SourceLocation::MacroIDBit) == 0);
GlobalSLocOffsetMap.insert(
std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
- SLocSpaceSize,&F));
@@ -3430,8 +3430,8 @@
// Invalid stays invalid.
F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
// This module. Base was 2 when being compiled.
- F.SLocRemap.insertOrReplace(std::make_pair(2U,
- static_cast<int>(F.SLocEntryBaseOffset - 2)));
+ F.SLocRemap.insertOrReplace(std::make_pair(
+ 2U, static_cast<SourceLocation::IntType>(F.SLocEntryBaseOffset - 2)));
TotalNumSLocEntries += F.LocalNumSLocEntries;
break;
@@ -3855,8 +3855,11 @@
}
// Continuous range maps we may be updating in our module.
+ using SLocRemapBuilder =
+ ContinuousRangeMap<SourceLocation::UIntType, SourceLocation::IntType,
+ 2>::Builder;
using RemapBuilder = ContinuousRangeMap<uint32_t, int, 2>::Builder;
- RemapBuilder SLocRemap(F.SLocRemap);
+ SLocRemapBuilder SLocRemap(F.SLocRemap);
RemapBuilder IdentifierRemap(F.IdentifierRemap);
RemapBuilder MacroRemap(F.MacroRemap);
RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
@@ -3887,8 +3890,8 @@
return;
}
- uint32_t SLocOffset =
- endian::readNext<uint32_t, little, unaligned>(Data);
+ SourceLocation::UIntType SLocOffset =
+ endian::readNext<SourceLocation::UIntType, little, unaligned>(Data);
uint32_t IdentifierIDOffset =
endian::readNext<uint32_t, little, unaligned>(Data);
uint32_t MacroIDOffset =
@@ -3904,15 +3907,21 @@
uint32_t TypeIndexOffset =
endian::readNext<uint32_t, little, unaligned>(Data);
- uint32_t None = std::numeric_limits<uint32_t>::max();
-
auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
RemapBuilder &Remap) {
+ constexpr uint32_t None = std::numeric_limits<uint32_t>::max();
if (Offset != None)
Remap.insert(std::make_pair(Offset,
static_cast<int>(BaseOffset - Offset)));
};
- mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap);
+
+ constexpr SourceLocation::UIntType SLocNone =
+ std::numeric_limits<SourceLocation::UIntType>::max();
+ if (SLocOffset != SLocNone)
+ SLocRemap.insert(std::make_pair(
+ SLocOffset, static_cast<SourceLocation::IntType>(
+ OM->SLocEntryBaseOffset - SLocOffset)));
+
mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
Index: clang/lib/Parse/ParseStmtAsm.cpp
===================================================================
--- clang/lib/Parse/ParseStmtAsm.cpp
+++ clang/lib/Parse/ParseStmtAsm.cpp
@@ -185,7 +185,7 @@
if (TokIndex < AsmToks.size()) {
const Token &Tok = AsmToks[TokIndex];
Loc = Tok.getLocation();
- Loc = Loc.getLocWithOffset(Offset - TokOffset);
+ Loc = Loc.getLocWithOffset((int)(Offset - TokOffset));
}
return Loc;
}
@@ -630,7 +630,7 @@
SmallVector<std::pair<void *, bool>, 4> OpExprs;
SmallVector<std::string, 4> Constraints;
SmallVector<std::string, 4> Clobbers;
- if (Parser->parseMSInlineAsm(AsmLoc.getPtrEncoding(), AsmStringIR, NumOutputs,
+ if (Parser->parseMSInlineAsm(AsmLoc.getRawEncoding(), AsmStringIR, NumOutputs,
NumInputs, OpExprs, Constraints, Clobbers,
MII.get(), IP.get(), Callback))
return StmtError();
Index: clang/lib/Lex/TokenLexer.cpp
===================================================================
--- clang/lib/Lex/TokenLexer.cpp
+++ clang/lib/Lex/TokenLexer.cpp
@@ -971,7 +971,7 @@
assert(SM.isInSLocAddrSpace(loc, MacroDefStart, MacroDefLength) &&
"Expected loc to come from the macro definition");
- unsigned relativeOffset = 0;
+ SourceLocation::UIntType relativeOffset = 0;
SM.isInSLocAddrSpace(loc, MacroDefStart, MacroDefLength, &relativeOffset);
return MacroExpansionStart.getLocWithOffset(relativeOffset);
}
@@ -1010,7 +1010,7 @@
if (CurLoc.isFileID() != NextLoc.isFileID())
break; // Token from different kind of FileID.
- int RelOffs;
+ SourceLocation::IntType RelOffs;
if (!SM.isInSameSLocAddrSpace(CurLoc, NextLoc, &RelOffs))
break; // Token from different local/loaded location.
// Check that token is not before the previous token or more than 50
@@ -1027,10 +1027,11 @@
// For the consecutive tokens, find the length of the SLocEntry to contain
// all of them.
Token &LastConsecutiveTok = *(NextTok-1);
- int LastRelOffs = 0;
+ SourceLocation::IntType LastRelOffs = 0;
SM.isInSameSLocAddrSpace(FirstLoc, LastConsecutiveTok.getLocation(),
&LastRelOffs);
- unsigned FullLength = LastRelOffs + LastConsecutiveTok.getLength();
+ SourceLocation::UIntType FullLength =
+ LastRelOffs + LastConsecutiveTok.getLength();
// Create a macro expansion SLocEntry that will "contain" all of the tokens.
SourceLocation Expansion =
@@ -1040,7 +1041,7 @@
// expanded location.
for (; begin_tokens < NextTok; ++begin_tokens) {
Token &Tok = *begin_tokens;
- int RelOffs = 0;
+ SourceLocation::IntType RelOffs = 0;
SM.isInSameSLocAddrSpace(FirstLoc, Tok.getLocation(), &RelOffs);
Tok.setLocation(Expansion.getLocWithOffset(RelOffs));
}
Index: clang/lib/Lex/PPCaching.cpp
===================================================================
--- clang/lib/Lex/PPCaching.cpp
+++ clang/lib/Lex/PPCaching.cpp
@@ -145,7 +145,7 @@
if (LastCachedTok.getKind() != Tok.getKind())
return false;
- int RelOffset = 0;
+ SourceLocation::IntType RelOffset = 0;
if ((!getSourceManager().isInSameSLocAddrSpace(
Tok.getLocation(), getLastCachedTokenLocation(), &RelOffset)) ||
RelOffset)
Index: clang/lib/Lex/ModuleMap.cpp
===================================================================
--- clang/lib/Lex/ModuleMap.cpp
+++ clang/lib/Lex/ModuleMap.cpp
@@ -1369,7 +1369,7 @@
RSquare
} Kind;
- unsigned Location;
+ SourceLocation::UIntType Location;
unsigned StringLength;
union {
// If Kind != IntegerLiteral.
Index: clang/lib/Lex/Lexer.cpp
===================================================================
--- clang/lib/Lex/Lexer.cpp
+++ clang/lib/Lex/Lexer.cpp
@@ -527,7 +527,7 @@
return Loc;
// Create a lexer starting at the beginning of this token.
- SourceLocation LexerStartLoc = Loc.getLocWithOffset(-LocInfo.second);
+ SourceLocation LexerStartLoc = Loc.getLocWithOffset(-(int)LocInfo.second);
Lexer TheLexer(LexerStartLoc, LangOpts, Buffer.data(), LexStart,
Buffer.end());
TheLexer.SetCommentRetentionState(true);
@@ -570,7 +570,8 @@
SM.getDecomposedLoc(BeginFileLoc);
assert(FileLocInfo.first == BeginFileLocInfo.first &&
FileLocInfo.second >= BeginFileLocInfo.second);
- return Loc.getLocWithOffset(BeginFileLocInfo.second - FileLocInfo.second);
+ return Loc.getLocWithOffset(
+ (int)(BeginFileLocInfo.second - FileLocInfo.second));
}
namespace {
@@ -588,7 +589,7 @@
// Create a lexer starting at the beginning of the file. Note that we use a
// "fake" file source location at offset 1 so that the lexer will track our
// position within the file.
- const unsigned StartOffset = 1;
+ const SourceLocation::UIntType StartOffset = 1;
SourceLocation FileLoc = SourceLocation::getFromRawEncoding(StartOffset);
Lexer TheLexer(FileLoc, LangOpts, Buffer.begin(), Buffer.begin(),
Buffer.end());
@@ -714,8 +715,9 @@
else
End = TheTok.getLocation();
- return PreambleBounds(End.getRawEncoding() - FileLoc.getRawEncoding(),
- TheTok.isAtStartOfLine());
+ return PreambleBounds(
+ (unsigned)(End.getRawEncoding() - FileLoc.getRawEncoding()),
+ TheTok.isAtStartOfLine());
}
unsigned Lexer::getTokenPrefixLength(SourceLocation TokStart, unsigned CharNo,
Index: clang/lib/Format/FormatTokenLexer.cpp
===================================================================
--- clang/lib/Format/FormatTokenLexer.cpp
+++ clang/lib/Format/FormatTokenLexer.cpp
@@ -850,7 +850,7 @@
FormatTok = new (Allocator.Allocate()) FormatToken;
readRawToken(*FormatTok);
SourceLocation WhitespaceStart =
- FormatTok->Tok.getLocation().getLocWithOffset(-TrailingWhitespace);
+ FormatTok->Tok.getLocation().getLocWithOffset(-(int)TrailingWhitespace);
FormatTok->IsFirst = IsFirstToken;
IsFirstToken = false;
Index: clang/lib/CodeGen/CoverageMappingGen.cpp
===================================================================
--- clang/lib/CodeGen/CoverageMappingGen.cpp
+++ clang/lib/CodeGen/CoverageMappingGen.cpp
@@ -242,7 +242,7 @@
/// Return the start location of an included file or expanded macro.
SourceLocation getStartOfFileOrMacro(SourceLocation Loc) {
if (Loc.isMacroID())
- return Loc.getLocWithOffset(-SM.getFileOffset(Loc));
+ return Loc.getLocWithOffset(-(int)SM.getFileOffset(Loc));
return SM.getLocForStartOfFile(SM.getFileID(Loc));
}
Index: clang/lib/CodeGen/CodeGenAction.cpp
===================================================================
--- clang/lib/CodeGen/CodeGenAction.cpp
+++ clang/lib/CodeGen/CodeGenAction.cpp
@@ -380,8 +380,8 @@
Gen->HandleVTable(RD);
}
- static void InlineAsmDiagHandler(const llvm::SMDiagnostic &SM,void *Context,
- unsigned LocCookie) {
+ static void InlineAsmDiagHandler(const llvm::SMDiagnostic &SM,
+ void *Context, uint64_t LocCookie) {
SourceLocation Loc = SourceLocation::getFromRawEncoding(LocCookie);
((BackendConsumer*)Context)->InlineAsmDiagHandler2(SM, Loc);
}
@@ -988,8 +988,7 @@
}
static void BitcodeInlineAsmDiagHandler(const llvm::SMDiagnostic &SM,
- void *Context,
- unsigned LocCookie) {
+ void *Context, uint64_t LocCookie) {
SM.print(nullptr, llvm::errs());
auto Diags = static_cast<DiagnosticsEngine *>(Context);
Index: clang/lib/CodeGen/CGStmt.cpp
===================================================================
--- clang/lib/CodeGen/CGStmt.cpp
+++ clang/lib/CodeGen/CGStmt.cpp
@@ -2095,7 +2095,7 @@
SmallVector<llvm::Metadata *, 8> Locs;
// Add the location of the first line to the MDNode.
Locs.push_back(llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
- CGF.Int32Ty, Str->getBeginLoc().getRawEncoding())));
+ CGF.Int64Ty, Str->getBeginLoc().getRawEncoding())));
StringRef StrVal = Str->getString();
if (!StrVal.empty()) {
const SourceManager &SM = CGF.CGM.getContext().getSourceManager();
@@ -2110,7 +2110,7 @@
SourceLocation LineLoc = Str->getLocationOfByte(
i + 1, SM, LangOpts, CGF.getTarget(), &StartToken, &ByteOffset);
Locs.push_back(llvm::ConstantAsMetadata::get(
- llvm::ConstantInt::get(CGF.Int32Ty, LineLoc.getRawEncoding())));
+ llvm::ConstantInt::get(CGF.Int64Ty, LineLoc.getRawEncoding())));
}
}
@@ -2145,8 +2145,8 @@
getAsmSrcLocInfo(gccAsmStmt->getAsmString(), CGF));
else {
// At least put the line number on MS inline asm blobs.
- llvm::Constant *Loc = llvm::ConstantInt::get(CGF.Int32Ty,
- S.getAsmLoc().getRawEncoding());
+ llvm::Constant *Loc =
+ llvm::ConstantInt::get(CGF.Int64Ty, S.getAsmLoc().getRawEncoding());
Result.setMetadata("srcloc",
llvm::MDNode::get(CGF.getLLVMContext(),
llvm::ConstantAsMetadata::get(Loc)));
Index: clang/lib/CodeGen/CGOpenMPRuntime.cpp
===================================================================
--- clang/lib/CodeGen/CGOpenMPRuntime.cpp
+++ clang/lib/CodeGen/CGOpenMPRuntime.cpp
@@ -11891,13 +11891,14 @@
// Cleanup action for allocate support.
class OMPAllocateCleanupTy final : public EHScopeStack::Cleanup {
llvm::FunctionCallee RTLFn;
- unsigned LocEncoding;
+ SourceLocation::UIntType LocEncoding;
Address Addr;
const Expr *Allocator;
public:
- OMPAllocateCleanupTy(llvm::FunctionCallee RTLFn, unsigned LocEncoding,
- Address Addr, const Expr *Allocator)
+ OMPAllocateCleanupTy(llvm::FunctionCallee RTLFn,
+ SourceLocation::UIntType LocEncoding, Address Addr,
+ const Expr *Allocator)
: RTLFn(RTLFn), LocEncoding(LocEncoding), Addr(Addr),
Allocator(Allocator) {}
void Emit(CodeGenFunction &CGF, Flags /*flags*/) override {
Index: clang/lib/Basic/SourceManager.cpp
===================================================================
--- clang/lib/Basic/SourceManager.cpp
+++ clang/lib/Basic/SourceManager.cpp
@@ -449,9 +449,9 @@
return LoadedSLocEntryTable[Index];
}
-std::pair<int, unsigned>
+std::pair<int, SourceLocation::UIntType>
SourceManager::AllocateLoadedSLocEntries(unsigned NumSLocEntries,
- unsigned TotalSize) {
+ SourceLocation::UIntType TotalSize) {
assert(ExternalSLocEntries && "Don't have an external sloc source");
// Make sure we're not about to run out of source locations.
if (CurrentLoadedOffset - TotalSize < NextLocalOffset)
@@ -531,7 +531,8 @@
FileID SourceManager::createFileID(const FileEntry *SourceFile,
SourceLocation IncludePos,
SrcMgr::CharacteristicKind FileCharacter,
- int LoadedID, unsigned LoadedOffset) {
+ int LoadedID,
+ SourceLocation::UIntType LoadedOffset) {
return createFileID(SourceFile->getLastRef(), IncludePos, FileCharacter,
LoadedID, LoadedOffset);
}
@@ -539,7 +540,8 @@
FileID SourceManager::createFileID(FileEntryRef SourceFile,
SourceLocation IncludePos,
SrcMgr::CharacteristicKind FileCharacter,
- int LoadedID, unsigned LoadedOffset) {
+ int LoadedID,
+ SourceLocation::UIntType LoadedOffset) {
SrcMgr::ContentCache &IR = getOrCreateContentCache(SourceFile,
isSystem(FileCharacter));
@@ -558,7 +560,8 @@
/// MemoryBuffer, so only pass a MemoryBuffer to this once.
FileID SourceManager::createFileID(std::unique_ptr<llvm::MemoryBuffer> Buffer,
SrcMgr::CharacteristicKind FileCharacter,
- int LoadedID, unsigned LoadedOffset,
+ int LoadedID,
+ SourceLocation::UIntType LoadedOffset,
SourceLocation IncludeLoc) {
StringRef Name = Buffer->getBufferIdentifier();
return createFileIDImpl(createMemBufferContentCache(std::move(Buffer)), Name,
@@ -571,7 +574,8 @@
/// outlive the SourceManager.
FileID SourceManager::createFileID(const llvm::MemoryBufferRef &Buffer,
SrcMgr::CharacteristicKind FileCharacter,
- int LoadedID, unsigned LoadedOffset,
+ int LoadedID,
+ SourceLocation::UIntType LoadedOffset,
SourceLocation IncludeLoc) {
return createFileID(llvm::MemoryBuffer::getMemBuffer(Buffer), FileCharacter,
LoadedID, LoadedOffset, IncludeLoc);
@@ -593,7 +597,8 @@
FileID SourceManager::createFileIDImpl(ContentCache &File, StringRef Filename,
SourceLocation IncludePos,
SrcMgr::CharacteristicKind FileCharacter,
- int LoadedID, unsigned LoadedOffset) {
+ int LoadedID,
+ SourceLocation::UIntType LoadedOffset) {
if (LoadedID < 0) {
assert(LoadedID != -1 && "Loading sentinel FileID");
unsigned Index = unsigned(-LoadedID) - 2;
@@ -632,14 +637,11 @@
return createExpansionLocImpl(Info, TokLength);
}
-SourceLocation
-SourceManager::createExpansionLoc(SourceLocation SpellingLoc,
- SourceLocation ExpansionLocStart,
- SourceLocation ExpansionLocEnd,
- unsigned TokLength,
- bool ExpansionIsTokenRange,
- int LoadedID,
- unsigned LoadedOffset) {
+SourceLocation SourceManager::createExpansionLoc(
+ SourceLocation SpellingLoc, SourceLocation ExpansionLocStart,
+ SourceLocation ExpansionLocEnd, unsigned TokLength,
+ bool ExpansionIsTokenRange, int LoadedID,
+ SourceLocation::UIntType LoadedOffset) {
ExpansionInfo Info = ExpansionInfo::create(
SpellingLoc, ExpansionLocStart, ExpansionLocEnd, ExpansionIsTokenRange);
return createExpansionLocImpl(Info, TokLength, LoadedID, LoadedOffset);
@@ -657,9 +659,8 @@
SourceLocation
SourceManager::createExpansionLocImpl(const ExpansionInfo &Info,
- unsigned TokLength,
- int LoadedID,
- unsigned LoadedOffset) {
+ unsigned TokLength, int LoadedID,
+ SourceLocation::UIntType LoadedOffset) {
if (LoadedID < 0) {
assert(LoadedID != -1 && "Loading sentinel FileID");
unsigned Index = unsigned(-LoadedID) - 2;
@@ -761,7 +762,7 @@
/// This is the cache-miss path of getFileID. Not as hot as that function, but
/// still very important. It is responsible for finding the entry in the
/// SLocEntry tables that contains the specified location.
-FileID SourceManager::getFileIDSlow(unsigned SLocOffset) const {
+FileID SourceManager::getFileIDSlow(SourceLocation::UIntType SLocOffset) const {
if (!SLocOffset)
return FileID::get(0);
@@ -776,7 +777,8 @@
///
/// This function knows that the SourceLocation is in a local buffer, not a
/// loaded one.
-FileID SourceManager::getFileIDLocal(unsigned SLocOffset) const {
+FileID
+SourceManager::getFileIDLocal(SourceLocation::UIntType SLocOffset) const {
assert(SLocOffset < NextLocalOffset && "Bad function choice");
// After the first and second level caches, I see two common sorts of
@@ -827,7 +829,8 @@
NumProbes = 0;
while (true) {
unsigned MiddleIndex = (GreaterIndex-LessIndex)/2+LessIndex;
- unsigned MidOffset = getLocalSLocEntry(MiddleIndex).getOffset();
+ SourceLocation::UIntType MidOffset =
+ getLocalSLocEntry(MiddleIndex).getOffset();
++NumProbes;
@@ -858,7 +861,8 @@
///
/// This function knows that the SourceLocation is in a loaded buffer, not a
/// local one.
-FileID SourceManager::getFileIDLoaded(unsigned SLocOffset) const {
+FileID
+SourceManager::getFileIDLoaded(SourceLocation::UIntType SLocOffset) const {
// Sanity checking, otherwise a bug may lead to hanging in release build.
if (SLocOffset < CurrentLoadedOffset) {
assert(0 && "Invalid SLocOffset or bad function choice");
@@ -1572,7 +1576,7 @@
return 0;
int ID = FID.ID;
- unsigned NextOffset;
+ SourceLocation::UIntType NextOffset;
if ((ID > 0 && unsigned(ID+1) == local_sloc_entry_size()))
NextOffset = getNextLocalOffset();
else if (ID+1 == -1)
@@ -1780,8 +1784,8 @@
SourceLocation ExpansionLoc,
unsigned ExpansionLength) const {
if (!SpellLoc.isFileID()) {
- unsigned SpellBeginOffs = SpellLoc.getOffset();
- unsigned SpellEndOffs = SpellBeginOffs + ExpansionLength;
+ SourceLocation::UIntType SpellBeginOffs = SpellLoc.getOffset();
+ SourceLocation::UIntType SpellEndOffs = SpellBeginOffs + ExpansionLength;
// The spelling range for this macro argument expansion can span multiple
// consecutive FileID entries. Go through each entry contained in the
@@ -1793,9 +1797,10 @@
std::tie(SpellFID, SpellRelativeOffs) = getDecomposedLoc(SpellLoc);
while (true) {
const SLocEntry &Entry = getSLocEntry(SpellFID);
- unsigned SpellFIDBeginOffs = Entry.getOffset();
+ SourceLocation::UIntType SpellFIDBeginOffs = Entry.getOffset();
unsigned SpellFIDSize = getFileIDSize(SpellFID);
- unsigned SpellFIDEndOffs = SpellFIDBeginOffs + SpellFIDSize;
+ SourceLocation::UIntType SpellFIDEndOffs =
+ SpellFIDBeginOffs + SpellFIDSize;
const ExpansionInfo &Info = Entry.getExpansion();
if (Info.isMacroArgExpansion()) {
unsigned CurrSpellLength;
@@ -1887,7 +1892,7 @@
--I;
- unsigned MacroArgBeginOffs = I->first;
+ SourceLocation::UIntType MacroArgBeginOffs = I->first;
SourceLocation MacroArgExpandedLoc = I->second;
if (MacroArgExpandedLoc.isValid())
return MacroArgExpandedLoc.getLocWithOffset(Offset - MacroArgBeginOffs);
@@ -2107,7 +2112,7 @@
llvm::raw_ostream &out = llvm::errs();
auto DumpSLocEntry = [&](int ID, const SrcMgr::SLocEntry &Entry,
- llvm::Optional<unsigned> NextStart) {
+ llvm::Optional<SourceLocation::UIntType> NextStart) {
out << "SLocEntry <FileID " << ID << "> " << (Entry.isFile() ? "file" : "expansion")
<< " <SourceLocation " << Entry.getOffset() << ":";
if (NextStart)
@@ -2147,7 +2152,7 @@
: LocalSLocEntryTable[ID + 1].getOffset());
}
// Dump loaded SLocEntries.
- llvm::Optional<unsigned> NextStart;
+ llvm::Optional<SourceLocation::UIntType> NextStart;
for (unsigned Index = 0; Index != LoadedSLocEntryTable.size(); ++Index) {
int ID = -(int)Index - 2;
if (SLocEntryLoaded[Index]) {
Index: clang/lib/Basic/SourceLocation.cpp
===================================================================
--- clang/lib/Basic/SourceLocation.cpp
+++ clang/lib/Basic/SourceLocation.cpp
@@ -51,7 +51,7 @@
"used in unions");
unsigned SourceLocation::getHashValue() const {
- return llvm::DenseMapInfo<unsigned>::getHashValue(ID);
+ return llvm::DenseMapInfo<UIntType>::getHashValue(ID);
}
void llvm::FoldingSetTrait<SourceLocation>::Profile(
Index: clang/lib/AST/SelectorLocationsKind.cpp
===================================================================
--- clang/lib/AST/SelectorLocationsKind.cpp
+++ clang/lib/AST/SelectorLocationsKind.cpp
@@ -27,7 +27,7 @@
if (EndLoc.isInvalid())
return SourceLocation();
IdentifierInfo *II = Sel.getIdentifierInfoForSlot(0);
- unsigned Len = II ? II->getLength() : 0;
+ int Len = II ? II->getLength() : 0;
return EndLoc.getLocWithOffset(-Len);
}
@@ -35,7 +35,7 @@
if (ArgLoc.isInvalid())
return SourceLocation();
IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Index);
- unsigned Len = /* selector id */ (II ? II->getLength() : 0) + /* ':' */ 1;
+ int Len = /* selector id */ (II ? II->getLength() : 0) + /* ':' */ 1;
if (WithArgSpace)
++Len;
return ArgLoc.getLocWithOffset(-Len);
Index: clang/lib/AST/NestedNameSpecifier.cpp
===================================================================
--- clang/lib/AST/NestedNameSpecifier.cpp
+++ clang/lib/AST/NestedNameSpecifier.cpp
@@ -355,7 +355,7 @@
assert(Qualifier && "Expected a non-NULL qualifier");
// Location of the trailing '::'.
- unsigned Length = sizeof(unsigned);
+ unsigned Length = sizeof(SourceLocation::UIntType);
switch (Qualifier->getKind()) {
case NestedNameSpecifier::Global:
@@ -367,7 +367,7 @@
case NestedNameSpecifier::NamespaceAlias:
case NestedNameSpecifier::Super:
// The location of the identifier or namespace name.
- Length += sizeof(unsigned);
+ Length += sizeof(SourceLocation::UIntType);
break;
case NestedNameSpecifier::TypeSpecWithTemplate:
@@ -392,8 +392,8 @@
/// Load a (possibly unaligned) source location from a given address
/// and offset.
static SourceLocation LoadSourceLocation(void *Data, unsigned Offset) {
- unsigned Raw;
- memcpy(&Raw, static_cast<char *>(Data) + Offset, sizeof(unsigned));
+ SourceLocation::UIntType Raw;
+ memcpy(&Raw, static_cast<char *>(Data) + Offset, sizeof(Raw));
return SourceLocation::getFromRawEncoding(Raw);
}
@@ -430,8 +430,9 @@
case NestedNameSpecifier::Namespace:
case NestedNameSpecifier::NamespaceAlias:
case NestedNameSpecifier::Super:
- return SourceRange(LoadSourceLocation(Data, Offset),
- LoadSourceLocation(Data, Offset + sizeof(unsigned)));
+ return SourceRange(
+ LoadSourceLocation(Data, Offset),
+ LoadSourceLocation(Data, Offset + sizeof(SourceLocation::UIntType)));
case NestedNameSpecifier::TypeSpecWithTemplate:
case NestedNameSpecifier::TypeSpec: {
@@ -486,10 +487,10 @@
/// Save a source location to the given buffer.
static void SaveSourceLocation(SourceLocation Loc, char *&Buffer,
unsigned &BufferSize, unsigned &BufferCapacity) {
- unsigned Raw = Loc.getRawEncoding();
+ SourceLocation::UIntType Raw = Loc.getRawEncoding();
Append(reinterpret_cast<char *>(&Raw),
- reinterpret_cast<char *>(&Raw) + sizeof(unsigned),
- Buffer, BufferSize, BufferCapacity);
+ reinterpret_cast<char *>(&Raw) + sizeof(Raw), Buffer, BufferSize,
+ BufferCapacity);
}
/// Save a pointer to the given buffer.
Index: clang/lib/ARCMigrate/TransEmptyStatementsAndDealloc.cpp
===================================================================
--- clang/lib/ARCMigrate/TransEmptyStatementsAndDealloc.cpp
+++ clang/lib/ARCMigrate/TransEmptyStatementsAndDealloc.cpp
@@ -52,7 +52,7 @@
if (AfterMacroLoc == SemiLoc)
return true;
- int RelOffs = 0;
+ SourceLocation::IntType RelOffs = 0;
if (!SM.isInSameSLocAddrSpace(AfterMacroLoc, SemiLoc, &RelOffs))
return false;
if (RelOffs < 0)
Index: clang/include/clang/Serialization/ModuleFile.h
===================================================================
--- clang/include/clang/Serialization/ModuleFile.h
+++ clang/include/clang/Serialization/ModuleFile.h
@@ -260,7 +260,7 @@
int SLocEntryBaseID = 0;
/// The base offset in the source manager's view of this module.
- unsigned SLocEntryBaseOffset = 0;
+ SourceLocation::UIntType SLocEntryBaseOffset = 0;
/// Base file offset for the offsets in SLocEntryOffsets. Real file offset
/// for the entry is SLocEntryOffsetsBase + SLocEntryOffsets[i].
@@ -274,7 +274,8 @@
SmallVector<uint64_t, 4> PreloadSLocEntries;
/// Remapping table for source locations in this module.
- ContinuousRangeMap<uint32_t, int, 2> SLocRemap;
+ ContinuousRangeMap<SourceLocation::UIntType, SourceLocation::IntType, 2>
+ SLocRemap;
// === Identifiers ===
Index: clang/include/clang/Serialization/ASTWriter.h
===================================================================
--- clang/include/clang/Serialization/ASTWriter.h
+++ clang/include/clang/Serialization/ASTWriter.h
@@ -347,7 +347,7 @@
union {
const Decl *Dcl;
void *Type;
- unsigned Loc;
+ SourceLocation::UIntType Loc;
unsigned Val;
Module *Mod;
const Attr *Attribute;
Index: clang/include/clang/Serialization/ASTReader.h
===================================================================
--- clang/include/clang/Serialization/ASTReader.h
+++ clang/include/clang/Serialization/ASTReader.h
@@ -2137,12 +2137,15 @@
/// Read a source location from raw form and return it in its
/// originating module file's source location space.
- SourceLocation ReadUntranslatedSourceLocation(uint32_t Raw) const {
- return SourceLocation::getFromRawEncoding((Raw >> 1) | (Raw << 31));
+ SourceLocation
+ ReadUntranslatedSourceLocation(SourceLocation::UIntType Raw) const {
+ return SourceLocation::getFromRawEncoding((Raw >> 1) |
+ (Raw << (8 * sizeof(Raw) - 1)));
}
/// Read a source location from raw form.
- SourceLocation ReadSourceLocation(ModuleFile &ModuleFile, uint32_t Raw) const {
+ SourceLocation ReadSourceLocation(ModuleFile &ModuleFile,
+ SourceLocation::UIntType Raw) const {
SourceLocation Loc = ReadUntranslatedSourceLocation(Raw);
return TranslateSourceLocation(ModuleFile, Loc);
}
@@ -2156,7 +2159,8 @@
assert(ModuleFile.SLocRemap.find(Loc.getOffset()) !=
ModuleFile.SLocRemap.end() &&
"Cannot find offset to remap.");
- int Remap = ModuleFile.SLocRemap.find(Loc.getOffset())->second;
+ SourceLocation::IntType Remap =
+ ModuleFile.SLocRemap.find(Loc.getOffset())->second;
return Loc.getLocWithOffset(Remap);
}
Index: clang/include/clang/Serialization/ASTBitCodes.h
===================================================================
--- clang/include/clang/Serialization/ASTBitCodes.h
+++ clang/include/clang/Serialization/ASTBitCodes.h
@@ -176,10 +176,10 @@
/// Source range/offset of a preprocessed entity.
struct PPEntityOffset {
/// Raw source location of beginning of range.
- unsigned Begin;
+ SourceLocation::UIntType Begin;
/// Raw source location of end of range.
- unsigned End;
+ SourceLocation::UIntType End;
/// Offset in the AST file relative to ModuleFile::MacroOffsetsBase.
uint32_t BitOffset;
@@ -200,9 +200,9 @@
/// Source range of a skipped preprocessor region
struct PPSkippedRange {
/// Raw source location of beginning of range.
- unsigned Begin;
+ SourceLocation::UIntType Begin;
/// Raw source location of end of range.
- unsigned End;
+ SourceLocation::UIntType End;
PPSkippedRange(SourceRange R)
: Begin(R.getBegin().getRawEncoding()),
@@ -240,7 +240,7 @@
/// Source location and bit offset of a declaration.
struct DeclOffset {
/// Raw source location.
- unsigned Loc = 0;
+ SourceLocation::UIntType Loc = 0;
/// Offset relative to the start of the DECLTYPES_BLOCK block. Keep
/// structure alignment 32-bit and avoid padding gap because undefined
Index: clang/include/clang/Lex/Token.h
===================================================================
--- clang/include/clang/Lex/Token.h
+++ clang/include/clang/Lex/Token.h
@@ -33,7 +33,7 @@
/// information about the SourceRange of the tokens and the type object.
class Token {
/// The location of the token. This is actually a SourceLocation.
- unsigned Loc;
+ SourceLocation::UIntType Loc;
// Conceptually these next two fields could be in a union. However, this
// causes gcc 4.2 to pessimize LexTokenInternal, a very performance critical
@@ -43,7 +43,7 @@
/// UintData - This holds either the length of the token text, when
/// a normal token, or the end of the SourceRange when an annotation
/// token.
- unsigned UintData;
+ SourceLocation::UIntType UintData;
/// PtrData - This is a union of four different pointer types, which depends
/// on what type of token this is:
Index: clang/include/clang/Lex/Preprocessor.h
===================================================================
--- clang/include/clang/Lex/Preprocessor.h
+++ clang/include/clang/Lex/Preprocessor.h
@@ -781,8 +781,7 @@
/// deserializing from PCH, we don't need to deserialize identifier & macros
/// just so that we can report that they are unused, we just warn using
/// the SourceLocations of this set (that will be filled by the ASTReader).
- /// We are using SmallPtrSet instead of a vector for faster removal.
- using WarnUnusedMacroLocsTy = llvm::SmallPtrSet<SourceLocation, 32>;
+ using WarnUnusedMacroLocsTy = llvm::SmallDenseSet<SourceLocation, 32>;
WarnUnusedMacroLocsTy WarnUnusedMacroLocs;
/// A "freelist" of MacroArg objects that can be
Index: clang/include/clang/Basic/SourceManager.h
===================================================================
--- clang/include/clang/Basic/SourceManager.h
+++ clang/include/clang/Basic/SourceManager.h
@@ -465,8 +465,9 @@
/// SourceManager keeps an array of these objects, and they are uniquely
/// identified by the FileID datatype.
class SLocEntry {
- unsigned Offset : 31;
- unsigned IsExpansion : 1;
+ static constexpr int OffsetBits = 8 * sizeof(SourceLocation::UIntType) - 1;
+ SourceLocation::UIntType Offset : OffsetBits;
+ SourceLocation::UIntType IsExpansion : 1;
union {
FileInfo File;
ExpansionInfo Expansion;
@@ -475,7 +476,7 @@
public:
SLocEntry() : Offset(), IsExpansion(), File() {}
- unsigned getOffset() const { return Offset; }
+ SourceLocation::UIntType getOffset() const { return Offset; }
bool isExpansion() const { return IsExpansion; }
bool isFile() const { return !isExpansion(); }
@@ -490,8 +491,8 @@
return Expansion;
}
- static SLocEntry get(unsigned Offset, const FileInfo &FI) {
- assert(!(Offset & (1u << 31)) && "Offset is too large");
+ static SLocEntry get(SourceLocation::UIntType Offset, const FileInfo &FI) {
+ assert(!(Offset & (1ULL << OffsetBits)) && "Offset is too large");
SLocEntry E;
E.Offset = Offset;
E.IsExpansion = false;
@@ -499,8 +500,9 @@
return E;
}
- static SLocEntry get(unsigned Offset, const ExpansionInfo &Expansion) {
- assert(!(Offset & (1u << 31)) && "Offset is too large");
+ static SLocEntry get(SourceLocation::UIntType Offset,
+ const ExpansionInfo &Expansion) {
+ assert(!(Offset & (1ULL << OffsetBits)) && "Offset is too large");
SLocEntry E;
E.Offset = Offset;
E.IsExpansion = true;
@@ -690,17 +692,18 @@
/// The starting offset of the next local SLocEntry.
///
/// This is LocalSLocEntryTable.back().Offset + the size of that entry.
- unsigned NextLocalOffset;
+ SourceLocation::UIntType NextLocalOffset;
/// The starting offset of the latest batch of loaded SLocEntries.
///
/// This is LoadedSLocEntryTable.back().Offset, except that that entry might
/// not have been loaded, so that value would be unknown.
- unsigned CurrentLoadedOffset;
+ SourceLocation::UIntType CurrentLoadedOffset;
- /// The highest possible offset is 2^31-1, so CurrentLoadedOffset
- /// starts at 2^31.
- static const unsigned MaxLoadedOffset = 1U << 31U;
+ /// The highest possible offset is 2^32-1 (2^63-1 for 64-bit source
+ /// locations), so CurrentLoadedOffset starts at 2^31 (2^63 resp.).
+ static const SourceLocation::UIntType MaxLoadedOffset =
+ 1ULL << (8 * sizeof(SourceLocation::UIntType) - 1);
/// A bitmap that indicates whether the entries of LoadedSLocEntryTable
/// have already been loaded from the external source.
@@ -865,11 +868,13 @@
/// This translates NULL into standard input.
FileID createFileID(const FileEntry *SourceFile, SourceLocation IncludePos,
SrcMgr::CharacteristicKind FileCharacter,
- int LoadedID = 0, unsigned LoadedOffset = 0);
+ int LoadedID = 0,
+ SourceLocation::UIntType LoadedOffset = 0);
FileID createFileID(FileEntryRef SourceFile, SourceLocation IncludePos,
SrcMgr::CharacteristicKind FileCharacter,
- int LoadedID = 0, unsigned LoadedOffset = 0);
+ int LoadedID = 0,
+ SourceLocation::UIntType LoadedOffset = 0);
/// Create a new FileID that represents the specified memory buffer.
///
@@ -877,7 +882,8 @@
/// MemoryBuffer, so only pass a MemoryBuffer to this once.
FileID createFileID(std::unique_ptr<llvm::MemoryBuffer> Buffer,
SrcMgr::CharacteristicKind FileCharacter = SrcMgr::C_User,
- int LoadedID = 0, unsigned LoadedOffset = 0,
+ int LoadedID = 0,
+ SourceLocation::UIntType LoadedOffset = 0,
SourceLocation IncludeLoc = SourceLocation());
/// Create a new FileID that represents the specified memory buffer.
@@ -886,7 +892,8 @@
/// outlive the SourceManager.
FileID createFileID(const llvm::MemoryBufferRef &Buffer,
SrcMgr::CharacteristicKind FileCharacter = SrcMgr::C_User,
- int LoadedID = 0, unsigned LoadedOffset = 0,
+ int LoadedID = 0,
+ SourceLocation::UIntType LoadedOffset = 0,
SourceLocation IncludeLoc = SourceLocation());
/// Get the FileID for \p SourceFile if it exists. Otherwise, create a
@@ -905,13 +912,11 @@
/// Return a new SourceLocation that encodes the fact
/// that a token from SpellingLoc should actually be referenced from
/// ExpansionLoc.
- SourceLocation createExpansionLoc(SourceLocation Loc,
- SourceLocation ExpansionLocStart,
- SourceLocation ExpansionLocEnd,
- unsigned TokLength,
- bool ExpansionIsTokenRange = true,
- int LoadedID = 0,
- unsigned LoadedOffset = 0);
+ SourceLocation
+ createExpansionLoc(SourceLocation Loc, SourceLocation ExpansionLocStart,
+ SourceLocation ExpansionLocEnd, unsigned TokLength,
+ bool ExpansionIsTokenRange = true, int LoadedID = 0,
+ SourceLocation::UIntType LoadedOffset = 0);
/// Return a new SourceLocation that encodes that the token starting
/// at \p TokenStart ends prematurely at \p TokenEnd.
@@ -1098,7 +1103,7 @@
/// the entry in SLocEntryTable which contains the specified location.
///
FileID getFileID(SourceLocation SpellingLoc) const {
- unsigned SLocOffset = SpellingLoc.getOffset();
+ SourceLocation::UIntType SLocOffset = SpellingLoc.getOffset();
// If our one-entry cache covers this offset, just return it.
if (isOffsetInFileID(LastFileIDLookup, SLocOffset))
@@ -1221,7 +1226,7 @@
if (!Entry)
return SourceLocation();
- unsigned GlobalOffset = Entry->getOffset() + Offset;
+ SourceLocation::UIntType GlobalOffset = Entry->getOffset() + Offset;
return Entry->isFile() ? SourceLocation::getFileLoc(GlobalOffset)
: SourceLocation::getMacroLoc(GlobalOffset);
}
@@ -1326,17 +1331,17 @@
///
/// If it's true and \p RelativeOffset is non-null, it will be set to the
/// relative offset of \p Loc inside the chunk.
- bool isInSLocAddrSpace(SourceLocation Loc,
- SourceLocation Start, unsigned Length,
- unsigned *RelativeOffset = nullptr) const {
+ bool
+ isInSLocAddrSpace(SourceLocation Loc, SourceLocation Start, unsigned Length,
+ SourceLocation::UIntType *RelativeOffset = nullptr) const {
assert(((Start.getOffset() < NextLocalOffset &&
Start.getOffset()+Length <= NextLocalOffset) ||
(Start.getOffset() >= CurrentLoadedOffset &&
Start.getOffset()+Length < MaxLoadedOffset)) &&
"Chunk is not valid SLoc address space");
- unsigned LocOffs = Loc.getOffset();
- unsigned BeginOffs = Start.getOffset();
- unsigned EndOffs = BeginOffs + Length;
+ SourceLocation::UIntType LocOffs = Loc.getOffset();
+ SourceLocation::UIntType BeginOffs = Start.getOffset();
+ SourceLocation::UIntType EndOffs = BeginOffs + Length;
if (LocOffs >= BeginOffs && LocOffs < EndOffs) {
if (RelativeOffset)
*RelativeOffset = LocOffs - BeginOffs;
@@ -1352,8 +1357,9 @@
/// If it's true and \p RelativeOffset is non-null, it will be set to the
/// offset of \p RHS relative to \p LHS.
bool isInSameSLocAddrSpace(SourceLocation LHS, SourceLocation RHS,
- int *RelativeOffset) const {
- unsigned LHSOffs = LHS.getOffset(), RHSOffs = RHS.getOffset();
+ SourceLocation::IntType *RelativeOffset) const {
+ SourceLocation::UIntType LHSOffs = LHS.getOffset(),
+ RHSOffs = RHS.getOffset();
bool LHSLoaded = LHSOffs >= CurrentLoadedOffset;
bool RHSLoaded = RHSOffs >= CurrentLoadedOffset;
@@ -1517,7 +1523,7 @@
/// of FileID) to \p relativeOffset.
bool isInFileID(SourceLocation Loc, FileID FID,
unsigned *RelativeOffset = nullptr) const {
- unsigned Offs = Loc.getOffset();
+ SourceLocation::UIntType Offs = Loc.getOffset();
if (isOffsetInFileID(FID, Offs)) {
if (RelativeOffset)
*RelativeOffset = Offs - getSLocEntry(FID).getOffset();
@@ -1636,8 +1642,9 @@
/// offset in the "source location address space".
///
/// Note that we always consider source locations loaded from
- bool isBeforeInSLocAddrSpace(SourceLocation LHS, unsigned RHS) const {
- unsigned LHSOffset = LHS.getOffset();
+ bool isBeforeInSLocAddrSpace(SourceLocation LHS,
+ SourceLocation::UIntType RHS) const {
+ SourceLocation::UIntType LHSOffset = LHS.getOffset();
bool LHSLoaded = LHSOffset >= CurrentLoadedOffset;
bool RHSLoaded = RHS >= CurrentLoadedOffset;
if (LHSLoaded == RHSLoaded)
@@ -1699,7 +1706,9 @@
return getSLocEntryByID(FID.ID, Invalid);
}
- unsigned getNextLocalOffset() const { return NextLocalOffset; }
+ SourceLocation::UIntType getNextLocalOffset() const {
+ return NextLocalOffset;
+ }
void setExternalSLocEntrySource(ExternalSLocEntrySource *Source) {
assert(LoadedSLocEntryTable.empty() &&
@@ -1713,8 +1722,9 @@
/// NumSLocEntries will be allocated, which occupy a total of TotalSize space
/// in the global source view. The lowest ID and the base offset of the
/// entries will be returned.
- std::pair<int, unsigned>
- AllocateLoadedSLocEntries(unsigned NumSLocEntries, unsigned TotalSize);
+ std::pair<int, SourceLocation::UIntType>
+ AllocateLoadedSLocEntries(unsigned NumSLocEntries,
+ SourceLocation::UIntType TotalSize);
/// Returns true if \p Loc came from a PCH/Module.
bool isLoadedSourceLocation(SourceLocation Loc) const {
@@ -1795,14 +1805,15 @@
/// Implements the common elements of storing an expansion info struct into
/// the SLocEntry table and producing a source location that refers to it.
- SourceLocation createExpansionLocImpl(const SrcMgr::ExpansionInfo &Expansion,
- unsigned TokLength,
- int LoadedID = 0,
- unsigned LoadedOffset = 0);
+ SourceLocation
+ createExpansionLocImpl(const SrcMgr::ExpansionInfo &Expansion,
+ unsigned TokLength, int LoadedID = 0,
+ SourceLocation::UIntType LoadedOffset = 0);
/// Return true if the specified FileID contains the
/// specified SourceLocation offset. This is a very hot method.
- inline bool isOffsetInFileID(FileID FID, unsigned SLocOffset) const {
+ inline bool isOffsetInFileID(FileID FID,
+ SourceLocation::UIntType SLocOffset) const {
const SrcMgr::SLocEntry &Entry = getSLocEntry(FID);
// If the entry is after the offset, it can't contain it.
if (SLocOffset < Entry.getOffset()) return false;
@@ -1836,7 +1847,7 @@
FileID createFileIDImpl(SrcMgr::ContentCache &File, StringRef Filename,
SourceLocation IncludePos,
SrcMgr::CharacteristicKind DirCharacter, int LoadedID,
- unsigned LoadedOffset);
+ SourceLocation::UIntType LoadedOffset);
SrcMgr::ContentCache &getOrCreateContentCache(FileEntryRef SourceFile,
bool isSystemFile = false);
@@ -1845,9 +1856,9 @@
SrcMgr::ContentCache &
createMemBufferContentCache(std::unique_ptr<llvm::MemoryBuffer> Buf);
- FileID getFileIDSlow(unsigned SLocOffset) const;
- FileID getFileIDLocal(unsigned SLocOffset) const;
- FileID getFileIDLoaded(unsigned SLocOffset) const;
+ FileID getFileIDSlow(SourceLocation::UIntType SLocOffset) const;
+ FileID getFileIDLocal(SourceLocation::UIntType SLocOffset) const;
+ FileID getFileIDLoaded(SourceLocation::UIntType SLocOffset) const;
SourceLocation getExpansionLocSlowCase(SourceLocation Loc) const;
SourceLocation getSpellingLocSlowCase(SourceLocation Loc) const;
Index: clang/include/clang/Basic/SourceLocation.h
===================================================================
--- clang/include/clang/Basic/SourceLocation.h
+++ clang/include/clang/Basic/SourceLocation.h
@@ -85,18 +85,26 @@
/// In addition, one bit of SourceLocation is used for quick access to the
/// information whether the location is in a file or a macro expansion.
///
-/// It is important that this type remains small. It is currently 32 bits wide.
+/// It is important that this type remains small. It is currently 32/64 bits
+/// wide.
class SourceLocation {
friend class ASTReader;
friend class ASTWriter;
friend class SourceManager;
friend struct llvm::FoldingSetTrait<SourceLocation>;
- unsigned ID = 0;
+public:
+#ifdef CLANG_64_BIT_SOURCE_LOCATIONS
+ using UIntType = uint64_t;
+ using IntType = int64_t;
+#else
+ using UIntType = uint32_t;
+ using IntType = int32_t;
+#endif
+private:
+ UIntType ID = 0;
- enum : unsigned {
- MacroIDBit = 1U << 31
- };
+ enum : UIntType { MacroIDBit = 1ULL << (8 * sizeof(UIntType) - 1) };
public:
bool isFileID() const { return (ID & MacroIDBit) == 0; }
@@ -112,18 +120,16 @@
private:
/// Return the offset into the manager's global input view.
- unsigned getOffset() const {
- return ID & ~MacroIDBit;
- }
+ UIntType getOffset() const { return ID & ~MacroIDBit; }
- static SourceLocation getFileLoc(unsigned ID) {
+ static SourceLocation getFileLoc(UIntType ID) {
assert((ID & MacroIDBit) == 0 && "Ran out of source locations!");
SourceLocation L;
L.ID = ID;
return L;
}
- static SourceLocation getMacroLoc(unsigned ID) {
+ static SourceLocation getMacroLoc(UIntType ID) {
assert((ID & MacroIDBit) == 0 && "Ran out of source locations!");
SourceLocation L;
L.ID = MacroIDBit | ID;
@@ -133,7 +139,7 @@
public:
/// Return a source location with the specified offset from this
/// SourceLocation.
- SourceLocation getLocWithOffset(int Offset) const {
+ SourceLocation getLocWithOffset(IntType Offset) const {
assert(((getOffset()+Offset) & MacroIDBit) == 0 && "offset overflow");
SourceLocation L;
L.ID = ID+Offset;
@@ -145,13 +151,13 @@
///
/// This should only be passed to SourceLocation::getFromRawEncoding, it
/// should not be inspected directly.
- unsigned getRawEncoding() const { return ID; }
+ UIntType getRawEncoding() const { return ID; }
/// Turn a raw encoding of a SourceLocation object into
/// a real SourceLocation.
///
/// \see getRawEncoding.
- static SourceLocation getFromRawEncoding(unsigned Encoding) {
+ static SourceLocation getFromRawEncoding(UIntType Encoding) {
SourceLocation X;
X.ID = Encoding;
return X;
@@ -171,7 +177,7 @@
/// Turn a pointer encoding of a SourceLocation object back
/// into a real SourceLocation.
static SourceLocation getFromPtrEncoding(const void *Encoding) {
- return getFromRawEncoding((unsigned)(uintptr_t)Encoding);
+ return getFromRawEncoding((SourceLocation::UIntType)(uintptr_t)Encoding);
}
static bool isPairOfFileLocations(SourceLocation Start, SourceLocation End) {
@@ -489,11 +495,13 @@
/// DenseMapInfo<unsigned> which uses SourceLocation::ID is used as a key.
template <> struct DenseMapInfo<clang::SourceLocation> {
static clang::SourceLocation getEmptyKey() {
- return clang::SourceLocation::getFromRawEncoding(~0U);
+ constexpr clang::SourceLocation::UIntType Zero = 0;
+ return clang::SourceLocation::getFromRawEncoding(~Zero);
}
static clang::SourceLocation getTombstoneKey() {
- return clang::SourceLocation::getFromRawEncoding(~0U - 1);
+ constexpr clang::SourceLocation::UIntType Zero = 0;
+ return clang::SourceLocation::getFromRawEncoding(~Zero - 1);
}
static unsigned getHashValue(clang::SourceLocation Loc) {
@@ -510,20 +518,6 @@
static void Profile(const clang::SourceLocation &X, FoldingSetNodeID &ID);
};
- // Teach SmallPtrSet how to handle SourceLocation.
- template<>
- struct PointerLikeTypeTraits<clang::SourceLocation> {
- static constexpr int NumLowBitsAvailable = 0;
-
- static void *getAsVoidPointer(clang::SourceLocation L) {
- return L.getPtrEncoding();
- }
-
- static clang::SourceLocation getFromVoidPointer(void *P) {
- return clang::SourceLocation::getFromRawEncoding((unsigned)(uintptr_t)P);
- }
- };
-
} // namespace llvm
#endif // LLVM_CLANG_BASIC_SOURCELOCATION_H
Index: clang/include/clang/Analysis/ProgramPoint.h
===================================================================
--- clang/include/clang/Analysis/ProgramPoint.h
+++ clang/include/clang/Analysis/ProgramPoint.h
@@ -21,6 +21,7 @@
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/PointerIntPair.h"
#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/AlignOf.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/DataTypes.h"
#include <cassert>
@@ -85,9 +86,31 @@
MaxImplicitCallKind = PostImplicitCallKind,
LoopExitKind,
EpsilonKind};
-
private:
- const void *Data1;
+ union PtrOrSLoc {
+ PtrOrSLoc() {}
+ PtrOrSLoc(const void *P) {
+ memset(Raw.buffer, 0, sizeof(Raw.buffer));
+ Ptr = P;
+ }
+ PtrOrSLoc(SourceLocation L) {
+ memset(Raw.buffer, 0, sizeof(Raw.buffer));
+ new (&SLoc) SourceLocation(L);
+ }
+ bool operator==(const PtrOrSLoc &RHS) const {
+ return memcmp(this, &RHS, sizeof(PtrOrSLoc)) == 0;
+ }
+ bool operator!=(const PtrOrSLoc &RHS) const { return !(*this == RHS); }
+ StringRef AsBuffer() const {
+ const char *c = (const char *)this;
+ return StringRef(c, sizeof(PtrOrSLoc));
+ }
+ const void *Ptr;
+ SourceLocation SLoc;
+ llvm::AlignedCharArrayUnion<void *, SourceLocation> Raw;
+ };
+
+ PtrOrSLoc Data1;
llvm::PointerIntPair<const void *, 2, unsigned> Data2;
// The LocationContext could be NULL to allow ProgramPoint to be used in
@@ -108,30 +131,38 @@
Tag(tag, (((unsigned) k) >> 4) & 0x3) {
assert(getKind() == k);
assert(getLocationContext() == l);
- assert(getData1() == P);
+ assert(getData1Ptr() == P);
}
- ProgramPoint(const void *P1,
- const void *P2,
- Kind k,
- const LocationContext *l,
- const ProgramPointTag *tag = nullptr)
- : Data1(P1),
- Data2(P2, (((unsigned) k) >> 0) & 0x3),
- L(l, (((unsigned) k) >> 2) & 0x3),
- Tag(tag, (((unsigned) k) >> 4) & 0x3) {}
-
-protected:
- const void *getData1() const { return Data1; }
- const void *getData2() const { return Data2.getPointer(); }
- void setData2(const void *d) { Data2.setPointer(d); }
-
-public:
- /// Create a new ProgramPoint object that is the same as the original
- /// except for using the specified tag value.
- ProgramPoint withTag(const ProgramPointTag *tag) const {
- return ProgramPoint(getData1(), getData2(), getKind(),
- getLocationContext(), tag);
+ ProgramPoint(PtrOrSLoc D1, const void *P2, Kind k,
+ const LocationContext *l,
+ const ProgramPointTag *tag = nullptr)
+ : Data1(D1), Data2(P2, (((unsigned)k) >> 0) & 0x3),
+ L(l, (((unsigned)k) >> 2) & 0x3),
+ Tag(tag, (((unsigned)k) >> 4) & 0x3) {}
+
+ ProgramPoint(const void *P1, const void *P2, Kind k,
+ const LocationContext *l,
+ const ProgramPointTag *tag = nullptr)
+ : ProgramPoint(PtrOrSLoc(P1), P2, k, l, tag) {}
+
+ ProgramPoint(SourceLocation Loc, const void *P2, Kind k,
+ const LocationContext *l,
+ const ProgramPointTag *tag = nullptr)
+ : ProgramPoint(PtrOrSLoc(Loc), P2, k, l, tag) {}
+
+ protected:
+ const PtrOrSLoc &getData1() const { return Data1; }
+ const void *getData1Ptr() const { return Data1.Ptr; }
+ const void *getData2() const { return Data2.getPointer(); }
+ void setData2(const void *d) { Data2.setPointer(d); }
+
+ public:
+ /// Create a new ProgramPoint object that is the same as the original
+ /// except for using the specified tag value.
+ ProgramPoint withTag(const ProgramPointTag *tag) const {
+ return ProgramPoint(getData1(), getData2(), getKind(),
+ getLocationContext(), tag);
}
/// Convert to the specified ProgramPoint type, asserting that this
@@ -207,7 +238,7 @@
void Profile(llvm::FoldingSetNodeID& ID) const {
ID.AddInteger((unsigned) getKind());
- ID.AddPointer(getData1());
+ ID.AddString(getData1().AsBuffer());
ID.AddPointer(getData2());
ID.AddPointer(getLocationContext());
ID.AddPointer(getTag());
@@ -231,7 +262,7 @@
}
const CFGBlock *getBlock() const {
- return reinterpret_cast<const CFGBlock*>(getData1());
+ return reinterpret_cast<const CFGBlock *>(getData1Ptr());
}
Optional<CFGElement> getFirstElement() const {
@@ -253,7 +284,7 @@
: ProgramPoint(B, BlockExitKind, L) {}
const CFGBlock *getBlock() const {
- return reinterpret_cast<const CFGBlock*>(getData1());
+ return reinterpret_cast<const CFGBlock *>(getData1Ptr());
}
const Stmt *getTerminator() const {
@@ -276,7 +307,7 @@
assert(S);
}
- const Stmt *getStmt() const { return (const Stmt*) getData1(); }
+ const Stmt *getStmt() const { return (const Stmt *)getData1Ptr(); }
template <typename T>
const T* getStmtAs() const { return dyn_cast<T>(getStmt()); }
@@ -344,7 +375,7 @@
}
const ReturnStmt *getStmt() const {
- return reinterpret_cast<const ReturnStmt *>(getData1());
+ return reinterpret_cast<const ReturnStmt *>(getData1Ptr());
}
private:
@@ -509,7 +540,7 @@
}
const CFGBlock *getSrc() const {
- return static_cast<const CFGBlock*>(getData1());
+ return static_cast<const CFGBlock *>(getData1Ptr());
}
const CFGBlock *getDst() const {
@@ -537,7 +568,7 @@
: ProgramPoint(I, Loc, PostInitializerKind, L) {}
const CXXCtorInitializer *getInitializer() const {
- return static_cast<const CXXCtorInitializer *>(getData1());
+ return static_cast<const CXXCtorInitializer *>(getData1Ptr());
}
/// Returns the location of the field.
@@ -560,12 +591,10 @@
public:
ImplicitCallPoint(const Decl *D, SourceLocation Loc, Kind K,
const LocationContext *L, const ProgramPointTag *Tag)
- : ProgramPoint(Loc.getPtrEncoding(), D, K, L, Tag) {}
+ : ProgramPoint(Loc, D, K, L, Tag) {}
const Decl *getDecl() const { return static_cast<const Decl *>(getData2()); }
- SourceLocation getLocation() const {
- return SourceLocation::getFromPtrEncoding(getData1());
- }
+ SourceLocation getLocation() const { return getData1().SLoc; }
protected:
ImplicitCallPoint() = default;
@@ -634,7 +663,7 @@
: ProgramPoint(stmt, calleeCtx, CallEnterKind, callerCtx, nullptr) {}
const Stmt *getCallExpr() const {
- return static_cast<const Stmt *>(getData1());
+ return static_cast<const Stmt *>(getData1Ptr());
}
const StackFrameContext *getCalleeContext() const {
@@ -672,7 +701,7 @@
: ProgramPoint(RS, CallExitBeginKind, L, nullptr) { }
const ReturnStmt *getReturnStmt() const {
- return static_cast<const ReturnStmt *>(getData1());
+ return static_cast<const ReturnStmt *>(getData1Ptr());
}
private:
@@ -693,7 +722,7 @@
: ProgramPoint(CalleeCtx, CallExitEndKind, CallerCtx, nullptr) {}
const StackFrameContext *getCalleeContext() const {
- return static_cast<const StackFrameContext *>(getData1());
+ return static_cast<const StackFrameContext *>(getData1Ptr());
}
private:
@@ -716,7 +745,7 @@
: ProgramPoint(LoopStmt, nullptr, LoopExitKind, LC) {}
const Stmt *getLoopStmt() const {
- return static_cast<const Stmt *>(getData1());
+ return static_cast<const Stmt *>(getData1Ptr());
}
private:
@@ -736,7 +765,7 @@
const ProgramPointTag *tag = nullptr)
: ProgramPoint(Data1, Data2, EpsilonKind, L, tag) {}
- const void *getData() const { return getData1(); }
+ const void *getData() const { return getData1Ptr(); }
private:
friend class ProgramPoint;
Index: clang/include/clang/AST/Stmt.h
===================================================================
--- clang/include/clang/AST/Stmt.h
+++ clang/include/clang/AST/Stmt.h
@@ -1151,7 +1151,7 @@
Stmt &operator=(Stmt &&) = delete;
Stmt(StmtClass SC) {
- static_assert(sizeof(*this) <= 8,
+ static_assert(sizeof(*this) <= 16,
"changing bitfields changed sizeof(Stmt)");
static_assert(sizeof(*this) % alignof(void *) == 0,
"Insufficient alignment!");
Index: clang/include/clang/AST/DeclarationName.h
===================================================================
--- clang/include/clang/AST/DeclarationName.h
+++ clang/include/clang/AST/DeclarationName.h
@@ -660,13 +660,13 @@
// The location (if any) of the operator keyword is stored elsewhere.
struct CXXOpName {
- unsigned BeginOpNameLoc;
- unsigned EndOpNameLoc;
+ SourceLocation::UIntType BeginOpNameLoc;
+ SourceLocation::UIntType EndOpNameLoc;
};
// The location (if any) of the operator keyword is stored elsewhere.
struct CXXLitOpName {
- unsigned OpNameLoc;
+ SourceLocation::UIntType OpNameLoc;
};
// struct {} CXXUsingDirective;
Index: clang/include/clang/AST/DeclBase.h
===================================================================
--- clang/include/clang/AST/DeclBase.h
+++ clang/include/clang/AST/DeclBase.h
@@ -1760,28 +1760,28 @@
LinkageSpecDeclBitfields LinkageSpecDeclBits;
BlockDeclBitfields BlockDeclBits;
- static_assert(sizeof(DeclContextBitfields) <= 8,
- "DeclContextBitfields is larger than 8 bytes!");
- static_assert(sizeof(TagDeclBitfields) <= 8,
- "TagDeclBitfields is larger than 8 bytes!");
- static_assert(sizeof(EnumDeclBitfields) <= 8,
- "EnumDeclBitfields is larger than 8 bytes!");
- static_assert(sizeof(RecordDeclBitfields) <= 8,
- "RecordDeclBitfields is larger than 8 bytes!");
- static_assert(sizeof(OMPDeclareReductionDeclBitfields) <= 8,
- "OMPDeclareReductionDeclBitfields is larger than 8 bytes!");
- static_assert(sizeof(FunctionDeclBitfields) <= 8,
- "FunctionDeclBitfields is larger than 8 bytes!");
- static_assert(sizeof(CXXConstructorDeclBitfields) <= 8,
- "CXXConstructorDeclBitfields is larger than 8 bytes!");
- static_assert(sizeof(ObjCMethodDeclBitfields) <= 8,
- "ObjCMethodDeclBitfields is larger than 8 bytes!");
- static_assert(sizeof(ObjCContainerDeclBitfields) <= 8,
- "ObjCContainerDeclBitfields is larger than 8 bytes!");
- static_assert(sizeof(LinkageSpecDeclBitfields) <= 8,
- "LinkageSpecDeclBitfields is larger than 8 bytes!");
- static_assert(sizeof(BlockDeclBitfields) <= 8,
- "BlockDeclBitfields is larger than 8 bytes!");
+ static_assert(sizeof(DeclContextBitfields) <= 16,
+ "DeclContextBitfields is larger than 16 bytes!");
+ static_assert(sizeof(TagDeclBitfields) <= 16,
+ "TagDeclBitfields is larger than 16 bytes!");
+ static_assert(sizeof(EnumDeclBitfields) <= 16,
+ "EnumDeclBitfields is larger than 16 bytes!");
+ static_assert(sizeof(RecordDeclBitfields) <= 16,
+ "RecordDeclBitfields is larger than 16 bytes!");
+ static_assert(sizeof(OMPDeclareReductionDeclBitfields) <= 16,
+ "OMPDeclareReductionDeclBitfields is larger than 16 bytes!");
+ static_assert(sizeof(FunctionDeclBitfields) <= 16,
+ "FunctionDeclBitfields is larger than 16 bytes!");
+ static_assert(sizeof(CXXConstructorDeclBitfields) <= 16,
+ "CXXConstructorDeclBitfields is larger than 16 bytes!");
+ static_assert(sizeof(ObjCMethodDeclBitfields) <= 16,
+ "ObjCMethodDeclBitfields is larger than 16 bytes!");
+ static_assert(sizeof(ObjCContainerDeclBitfields) <= 16,
+ "ObjCContainerDeclBitfields is larger than 16 bytes!");
+ static_assert(sizeof(LinkageSpecDeclBitfields) <= 16,
+ "LinkageSpecDeclBitfields is larger than 16 bytes!");
+ static_assert(sizeof(BlockDeclBitfields) <= 16,
+ "BlockDeclBitfields is larger than 16 bytes!");
};
/// FirstDecl - The first declaration stored within this declaration
Index: clang/include/clang-c/Index.h
===================================================================
--- clang/include/clang-c/Index.h
+++ clang/include/clang-c/Index.h
@@ -32,7 +32,7 @@
* The policy about the libclang API was always to keep it source and ABI
* compatible, thus CINDEX_VERSION_MAJOR is expected to remain stable.
*/
-#define CINDEX_VERSION_MAJOR 0
+#define CINDEX_VERSION_MAJOR 1
#define CINDEX_VERSION_MINOR 61
#define CINDEX_VERSION_ENCODE(major, minor) (((major)*10000) + ((minor)*1))
@@ -455,7 +455,7 @@
*/
typedef struct {
const void *ptr_data[2];
- unsigned int_data;
+ unsigned long long int_data;
} CXSourceLocation;
/**
@@ -466,8 +466,8 @@
*/
typedef struct {
const void *ptr_data[2];
- unsigned begin_int_data;
- unsigned end_int_data;
+ unsigned long long begin_int_data;
+ unsigned long long end_int_data;
} CXSourceRange;
/**
@@ -4973,7 +4973,8 @@
* Describes a single preprocessing token.
*/
typedef struct {
- unsigned int_data[4];
+ unsigned long long ulint_data[2];
+ unsigned uint_data[2];
void *ptr_data;
} CXToken;
@@ -6188,7 +6189,7 @@
*/
typedef struct {
void *ptr_data[2];
- unsigned int_data;
+ unsigned long long int_data;
} CXIdxLoc;
/**
Index: clang/bindings/python/clang/cindex.py
===================================================================
--- clang/bindings/python/clang/cindex.py
+++ clang/bindings/python/clang/cindex.py
@@ -233,7 +233,7 @@
"""
A SourceLocation represents a particular location within a source file.
"""
- _fields_ = [("ptr_data", c_void_p * 2), ("int_data", c_uint)]
+ _fields_ = [("ptr_data", c_void_p * 2), ("int_data", c_ulonglong)]
_data = None
def _get_instantiation(self):
@@ -307,8 +307,8 @@
"""
_fields_ = [
("ptr_data", c_void_p * 2),
- ("begin_int_data", c_uint),
- ("end_int_data", c_uint)]
+ ("begin_int_data", c_ulonglong),
+ ("end_int_data", c_ulonglong)]
# FIXME: Eliminate this and make normal constructor? Requires hiding ctypes
# object.
@@ -563,7 +563,8 @@
for i in range(0, count):
token = Token()
- token.int_data = tokens_array[i].int_data
+ token.uint_data = tokens_array[i].uint_data
+ token.ulint_data = tokens_array[i].ulint_data
token.ptr_data = tokens_array[i].ptr_data
token._tu = tu
token._group = token_group
@@ -3279,7 +3280,8 @@
can't create tokens manually.
"""
_fields_ = [
- ('int_data', c_uint * 4),
+ ('ulint_data', c_ulonglong * 2),
+ ('uint_data', c_uint * 2),
('ptr_data', c_void_p)
]
Index: clang/CMakeLists.txt
===================================================================
--- clang/CMakeLists.txt
+++ clang/CMakeLists.txt
@@ -333,6 +333,12 @@
"LLVM_LINK_LLVM_DYLIB=OFF")
endif()
+set(CLANG_64_BIT_SOURCE_LOCATIONS OFF CACHE BOOL
+ "SourceLocation underlying type is 64-bit")
+if (CLANG_64_BIT_SOURCE_LOCATIONS)
+ add_definitions(-DCLANG_64_BIT_SOURCE_LOCATIONS)
+endif()
+
# The libdir suffix must exactly match whatever LLVM's configuration used.
set(CLANG_LIBDIR_SUFFIX "${LLVM_LIBDIR_SUFFIX}")
Index: clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp
===================================================================
--- clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp
+++ clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp
@@ -131,12 +131,12 @@
// https://sonarcloud.io/projects?languages=c%2Ccpp&size=5 we can estimate:
// value ~20 would result in no allocs for 98% of functions, ~12 for 96%, ~10
// for 91%, ~8 for 88%, ~6 for 84%, ~4 for 77%, ~2 for 64%, and ~1 for 37%.
- static_assert(sizeof(Detail) <= 8,
+ static_assert(sizeof(Detail) <= 16,
"Since we use SmallVector to minimize the amount of "
"allocations, we also need to consider the price we pay for "
"that in terms of stack usage. "
"Thus, it is good to minimize the size of the Detail struct.");
- SmallVector<Detail, DefaultLimit> Details; // 25 elements is 200 bytes.
+ SmallVector<Detail, DefaultLimit> Details; // 25 elements is 400 bytes.
// Yes, 25 is a magic number. This is the seemingly-sane default for the
// upper limit for function cognitive complexity. Thus it would make sense
// to avoid allocations for any function that does not violate the limit.
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
