[RFC] Clang 64-bit source locations

[simon_tatham]

Summary

This patch is a draft implementation of 64-bit source locations in
Clang. The intent is to evaluate viability of using 64-bit source
locations.

The patch implements a compile-time switch for the bit width of source
locations.

The libclang ABI is unchanged, regardless of that compile-time switch.
So libclang clients will only be able to handle compilations whose
source locations all fit in 32 bits; internal clang SourceLocations
are bounds-checked before converting them to the libclang types, and
replaced with the 'null location' error indicator if the bounds check
fails.

This patch is a joint effort between Mikhail Maltsev and Simon Tatham.

Mikhail performed two benchmarks on a previous version of the patch to
evaluate the effects of the patch on memory consumption and
performance:

1. LLVM+Clang release build:
   • Average memory usage during a parallel (32 thread) build increased by 8.333 ± 0.185 % (95 % confidence interval)
   • Peak memory usage increased by 8.319 ± 1.680 %
   • Total time increased by 0.669 ± 0.047 %
2. Parsing and semantic analysis (i.e. -fsyntax-only) of a large C++ source file from the LLVM LNT test suite: https://github.com/llvm/llvm-test-suite/tree/main/MultiSource/Benchmarks/tramp3d-v4
   • Memory usage increased by 8.97 % (exact measurement)

The current version should improve on that somewhat, but no
measurements are available yet.

[akyrtzi]

Hi @miyuki,

A major thing worth noting is that 64-bit source locations will
require an ABI breakage in libclang. This patch changes the bit width
in libclang unconditionally, rather than making it configurable.

Is it possible to make the libclang change configurable as well? A libclang ABI breakage would be problematic for us at Apple. We support dynamically loading and using multiple libclang dylibs from different toolchains, which can be different clang versions.

[miyuki]

In D97204#2580490, @akyrtzi wrote:

Hi @miyuki,

A major thing worth noting is that 64-bit source locations will
require an ABI breakage in libclang. This patch changes the bit width
in libclang unconditionally, rather than making it configurable.

Is it possible to make the libclang change configurable as well? A libclang ABI breakage would be problematic for us at Apple. We support dynamically loading and using multiple libclang dylibs from different toolchains, which can be different clang versions.

Yes, this should be possible. Python bindings will need some adjustments, but nothing overly complicated.

[miyuki]

Fixed python bindings and formatting.

[rsmith]

Thanks for doing this!

The 8-9% memory hit is better than I'd feared, but still seems uncomfortably large. I've left comments on a couple of places where I think we could substantially reduce this.
The performance regression seems large enough that people will notice, but perhaps not prohibitively huge. I assume that's all caused by increasing the size of the working set.

Can we avoid a libclang ABI break if we don't allow the use of 64-bit source locations for builds with 32-bit pointers?

It would be useful to get data points from more users.

clang/include/clang/AST/DeclBase.h

1763–1784

I think allowing these to grow is likely a bad tradeoff -- we're paying 8 bytes per declaration in order to make only ObjCContainerDecls smaller (actually, not even that -- there'll be 4 bytes of padding in an ObjCContainerDecl either way in 64-bit-SourceLocation mode). Can you try moving the SourceLocation out of ObjCContainerDeclBitfields and into ObjCContainerDecl and see if that makes a noticeable difference to the memory overhead of this patch?

clang/include/clang/AST/Stmt.h

1154

Oof, we're wasting a lot of space here. Lots of Stmt subclasses only need a couple of bytes of bitfields, but we're padding them all out to 16 because some of them store a SourceLocation. It'd be nice to estimate how much of that we could get back by moving source locations to the derived classes, if you're prepared to do the work there. (I suspect that would result in too many #ifdefs to be reasonable to check in, though.)

clang/include/clang/Analysis/ProgramPoint.h

90–111

Can we reasonably say that 32-bit clang builds don't support 64-bit SourceLocations, and keep using a void* (or uintptr_t) here?

clang/lib/Serialization/ASTReader.cpp

3893–3894

I think we should ensure the on-disk AST file format doesn't depend on the new macro. Going to 64 bits unconditionally here is probably fine.

[akyrtzi]

In D97204#2586111, @rsmith wrote:

Can we avoid a libclang ABI break if we don't allow the use of 64-bit source locations for builds with 32-bit pointers?

To @rsmith's point, the simplest option may be to avoid building libclang if 64-bit source locations are enabled.

[miyuki]

In D97204#2586111, @rsmith wrote:

Thanks for doing this!

The 8-9% memory hit is better than I'd feared, but still seems uncomfortably large. I've left comments on a couple of places where I think we could substantially reduce this.

Thanks, I'll try that.

Can we avoid a libclang ABI break if we don't allow the use of 64-bit source locations for builds with 32-bit pointers?

No, unfortunately in some structs libclang stores source locations in 'unsigned int' fields, e.g. CXToken. In CXSourceLocation and CXSourceRange some space can be saved by an extra indirection, so 64-bit locations could fit there, AFAICT.

[simon_tatham]

@miyuki is working on other things at the moment, and I've picked this up.

This updated diff reverts the libclang ABI break completely. In the libclang ABI, there's still only 32 bits of space for a SourceLocation, and this is handled by bounds-checking on the clang side when converting into that format (and we return an invalid location if the bounds check fails). So any use of libclang that previously worked should still work, and ones that would previously have failed will now fail in a different way.

Perhaps in future we might introduce a secondary libclang ABI coexisting with the existing one, with different function names, and expanded data structures that can hold a full 64-bit SourceLocation? And then each client could switch over at their own convenience (or not at all).

I've addressed @rsmith's review suggestions by making a new pair of opaque structures called SourceLocation::LowBits and SourceLocation::OptionalHighBits, and a pair of functions to convert between a SourceLocation and a pair of those. So, in all the places where a SourceLocation was stored in one of those 'bits' unions, the union still contains a SourceLocation::LowBits containing 32 of the bits, and the derived class contains an OptionalHighBits which is zero size or another 32 bits depending on what size of SourceLocation we're compiling for.

The AST file format now uses a 64-bit field unconditionally for a source location. I'm not too familiar with this part of clang, but it looks as if AST files already have a versioning system based on the clang git commit id, so that incompatibility between this and the previous format will already be detected without me having to manually bump a format version number anywhere?

I haven't yet managed to repeat @miyuki's memory-usage analysis, so I can't say how much of the previous 9% loss is recovered by these changes. But I'll look at doing that next.

Incidentally, in passing I spotted what looks like an obvious bug in the libclang SourceLocation conversion code. Raised D104442 separately.

[simon_tatham]

Thanks to @miyuki for repeating the previous benchmark with this version of the patch (and on the same machine as before, which was better than I could have done).

The revised results now have the memory usage increase (compared to 32-bit SourceLocation) in the region of 5.5% to 7.5% instead of 8% to 9%. In detail:

• average memory usage during a clang build increased by 6.858 ± 0.260 %
• peak memory usage during a clang build increased by 5.529 ± 1.641 %
• memory usage during parsing of TraMP3d source file increased by 7.32 %

The change in speed between the previous version of the patch and this one is negligible (both values are within the uncertainty interval of the other one).

[simon_tatham]

Hmmm. Two people have pointed out to me that my strategy of having a 32-bit SourceLocations::LowBits and an 0- or 32-bit SourceLocations::OptionalHighBits doesn't actually work, because an empty struct still takes at least 1 byte. So this version of the patch will still increase memory usage in the 32SL configuration, which is just what I was trying to avoid. Whoops.

@rsmith, do you have any thoughts on what would be an acceptable replacement strategy? You mentioned wanting to avoid actual #ifdefs all over the AST class hierarchy. Some possible alternatives:

We could define a family of macros: one for declaring a possible-SourceLocation in a branch of the Stmt bitfields union, one for declaring the same SourceLocation in a particular Stmt subclass, and a pair for the accessor functions that read and write whichever of those exists. Then there'd be slightly ugly macro calls all over Stmt.h and friends, but only one outright #ifdef, where the macros are defined.

(And then there are two options for how to define the macros in the 64SL case: either move the whole SourceLocation into the subclasses for speed, or keep half of it in the bitfields as now, for space. But that decision could be localized into the macro definitions, and easily changed.)

Alternatively, @miyuki suggests that my SourceLocation::OptionalHighBits could become an extra base class of some of the Stmt subclasses, so that empty base optimization would allow it to take up 0 bytes in the 32SL configuration.

The macro approach is the kind of thing I wouldn't mind doing in my own projects, but then, I have a strong stomach for macros :-) and I'd rather check before I do all the work to rewrite this patch in one of those styles, only to find out that you'd prefer another, or something I haven't even thought of.

[simon_tatham]

This patch doesn't seem to have attracted much review attention in the last couple of weeks. On the theory that perhaps it's just too big and monolithic to review in one go, I've started to break it up into smaller pieces.

So far I've only covered the preparation stages, so I hope the following patches won't be too controversial:
D105490: Remove unused parameter from parseMSInlineAsm.
D105491: [clang] Use i64 for the !srcloc metadata on asm IR nodes.
D105492: [clang] Introduce SourceLocation::[U]IntType typedefs.
D105493: [clang] Change set type used for SourceLocation.
D105494: [clang] Introduce a union inside ProgramPoint.
D105495: [clang] Make negative getLocWithOffset widening-safe.
D105497: [clang] Serialize source locations as 64-bit in PCH.
D105498: [clang] Remove assumption about SourceLocation alignment.

[lenary]

Some of this patch set has been broken by https://reviews.llvm.org/D125403 and https://reviews.llvm.org/D125952 - which are size optimisations for PCH encodings of source locations. The biggest issue is new line 90 of clang/include/clang/Serialization/SourceLocationEncoding.h in the first patch.

I see the mini-patches in @simon_tatham's last comment have not unblocked this patch as much as was hoped, but maybe this comment can act as a reverse-ping?

[lebedev.ri]

This review may be stuck/dead, consider abandoning if no longer relevant.
Removing myself as reviewer in attempt to clean dashboard.

clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

struct CognitiveComplexity final {
 
   // Limit of 25 is the "upstream"'s default.
   static constexpr unsigned DefaultLimit = 25U;
 
   // Based on the publicly-avaliable numbers for some big open-source projects
   // 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.
 
   // The grand total Cognitive Complexity of the function.
   unsigned Total = 0;
 
   // The function used to store new increment, calculate the total complexity.

clang/CMakeLists.txt

 set(CLANG_LINK_CLANG_DYLIB ${LLVM_LINK_LLVM_DYLIB} CACHE BOOL
     "Link tools against libclang-cpp.so")
 
 if (NOT LLVM_LINK_LLVM_DYLIB AND CLANG_LINK_CLANG_DYLIB)
   message(FATAL_ERROR "Cannot set CLANG_LINK_CLANG_DYLIB=ON when "
                       "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}")
 
 set(CLANG_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(CLANG_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 
 if( CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE )
   message(FATAL_ERROR "In-source builds are not allowed. "

clang/bindings/python/clang/cindex.py

def from_result(res, fn=None, args=None):
         assert isinstance(res, _CXString)
         return conf.lib.clang_getCString(res)
 
 
 class SourceLocation(Structure):
     """
     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):
         if self._data is None:
             f, l, c, o = c_object_p(), c_uint(), c_uint(), c_uint()
             conf.lib.clang_getInstantiationLocation(self, byref(f), byref(l),
                     byref(c), byref(o))
             if f:

 
 class SourceRange(Structure):
     """
     A SourceRange describes a range of source locations within the source
     code.
     """
     _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.
     @staticmethod
     def from_locations(start, end):
         return conf.lib.clang_getRange(start, end)
 
     @property
def get_tokens(tu, extent):
             return
 
         tokens_array = cast(tokens_memory, POINTER(Token * count)).contents
 
         token_group = TokenGroup(tu, tokens_memory, tokens_count)
 
         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
 
             yield token
 
 class TokenKind(object):
     """Describes a specific type of a Token."""
class Token(Structure):
 
     Tokens are effectively segments of source code. Source code is first parsed
     into tokens before being converted into the AST and Cursors.
 
     Tokens are obtained from parsed TranslationUnit instances. You currently
     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)
     ]
 
     @property
     def spelling(self):
         """The spelling of this token.
 
         This is the textual representation of the token in source.

clang/include/clang-c/Index.h

 /**
  * The version constants for the libclang API.
  * CINDEX_VERSION_MINOR should increase when there are API additions.
  * CINDEX_VERSION_MAJOR is intended for "major" source/ABI breaking changes.
  *
  * 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))
 
 #define CINDEX_VERSION                                                         \
   CINDEX_VERSION_ENCODE(CINDEX_VERSION_MAJOR, CINDEX_VERSION_MINOR)
 
 #define CINDEX_VERSION_STRINGIZE_(major, minor) #major "." #minor

  * Identifies a specific source location within a translation
  * unit.
  *
  * Use clang_getExpansionLocation() or clang_getSpellingLocation()
  * to map a source location to a particular file, line, and column.
  */
 typedef struct {
   const void *ptr_data[2];
-  unsigned int_data;
+  unsigned long long int_data;
 } CXSourceLocation;
 
 /**
  * Identifies a half-open character range in the source code.
  *
  * Use clang_getRangeStart() and clang_getRangeEnd() to retrieve the
  * starting and end locations from a source range, respectively.
  */
 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;
 
 /**
  * Retrieve a NULL (invalid) source location.
  */
 CINDEX_LINKAGE CXSourceLocation clang_getNullLocation(void);
 
 /**
typedef enum CXTokenKind {
    */
   CXToken_Comment
 } CXTokenKind;
 
 /**
  * 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;
 
 /**
  * Get the raw lexical token starting with the given location.
  *
  * \param TU the translation unit whose text is being tokenized.
  *

  */
 typedef void *CXIdxClientASTFile;
 
 /**
  * Source location passed to index callbacks.
  */
 typedef struct {
   void *ptr_data[2];
-  unsigned int_data;
+  unsigned long long int_data;
 } CXIdxLoc;
 
 /**
  * Data for ppIncludedFile callback.
  */
 typedef struct {
   /**
    * Location of '#' in the \#include/\#import directive.

clang/include/clang/AST/DeclBase.h

union {
     OMPDeclareReductionDeclBitfields OMPDeclareReductionDeclBits;
     FunctionDeclBitfields FunctionDeclBits;
     CXXConstructorDeclBitfields CXXConstructorDeclBits;
     ObjCMethodDeclBitfields ObjCMethodDeclBits;
     ObjCContainerDeclBitfields ObjCContainerDeclBits;
     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
   /// context.
   mutable Decl *FirstDecl = nullptr;
 
   /// LastDecl - The last declaration stored within this declaration
   /// context. FIXME: We could probably cache this value somewhere

clang/include/clang/AST/DeclarationName.h

class DeclarationNameLoc {
   // Locations (if any) for the tilde (destructor) or operator keyword
   // (conversion) are stored elsewhere.
   struct NT {
     TypeSourceInfo *TInfo;
   };
 
   // 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;
   // struct {} ObjCZeroArgSelector;
   // struct {} ObjCOneArgSelector;
   // struct {} ObjCMultiArgSelector;
   union {
     struct NT NamedType;

clang/include/clang/AST/Stmt.h

 public:
   Stmt() = delete;
   Stmt(const Stmt &) = delete;
   Stmt(Stmt &&) = delete;
   Stmt &operator=(const Stmt &) = delete;
   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!");
     StmtBits.sClass = SC;
     if (StatisticsEnabled) Stmt::addStmtClass(SC);
   }
 
   StmtClass getStmtClass() const {

clang/include/clang/Analysis/ProgramPoint.h

 
 #include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
 #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>
 #include <string>
 #include <utility>
 
 namespace clang {
 
enum Kind { BlockEdgeKind,
               CallExitEndKind,
               FunctionExitKind,
               PreImplicitCallKind,
               PostImplicitCallKind,
               MinImplicitCallKind = PreImplicitCallKind,
               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
   // context insensitive analysis.
   llvm::PointerIntPair<const LocationContext *, 2, unsigned> L;
 
   llvm::PointerIntPair<const ProgramPointTag *, 2, unsigned> Tag;
 
 protected:
   ProgramPoint() = default;
   ProgramPoint(const void *P,
                Kind k,
                const LocationContext *l,
                const ProgramPointTag *tag = nullptr)
     : Data1(P),
       Data2(nullptr, (((unsigned) k) >> 0) & 0x3),
       L(l, (((unsigned) k) >> 2) & 0x3),
       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,
+      ProgramPoint(PtrOrSLoc D1, 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) {}
+          : 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 void *getData1() const { return Data1; }
+      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
   /// ProgramPoint is of the desired type.
   template<typename T>
   T castAs() const {
     assert(T::isKind(*this));
     T t;
     ProgramPoint& PP = t;
bool operator!=(const ProgramPoint &RHS) const {
     return Data1 != RHS.Data1 ||
            Data2 != RHS.Data2 ||
            L != RHS.L ||
            Tag != RHS.Tag;
   }
 
   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());
   }
 
   void printJson(llvm::raw_ostream &Out, const char *NL = "\n") const;
 
   LLVM_DUMP_METHOD void dump() const;
 
   static ProgramPoint getProgramPoint(const Stmt *S, ProgramPoint::Kind K,
                                       const LocationContext *LC,
                                       const ProgramPointTag *tag);
 };
 
 class BlockEntrance : public ProgramPoint {
 public:
   BlockEntrance(const CFGBlock *B, const LocationContext *L,
                 const ProgramPointTag *tag = nullptr)
     : ProgramPoint(B, BlockEntranceKind, L, tag) {
     assert(B && "BlockEntrance requires non-null block");
   }
 
   const CFGBlock *getBlock() const {
-    return reinterpret_cast<const CFGBlock*>(getData1());
+    return reinterpret_cast<const CFGBlock *>(getData1Ptr());
   }
 
   Optional<CFGElement> getFirstElement() const {
     const CFGBlock *B = getBlock();
     return B->empty() ? Optional<CFGElement>() : B->front();
   }
 
 private:
   friend class ProgramPoint;
   BlockEntrance() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == BlockEntranceKind;
   }
 };
 
 class BlockExit : public ProgramPoint {
 public:
   BlockExit(const CFGBlock *B, const LocationContext *L)
     : ProgramPoint(B, BlockExitKind, L) {}
 
   const CFGBlock *getBlock() const {
-    return reinterpret_cast<const CFGBlock*>(getData1());
+    return reinterpret_cast<const CFGBlock *>(getData1Ptr());
   }
 
   const Stmt *getTerminator() const {
     return getBlock()->getTerminatorStmt();
   }
 
 private:
   friend class ProgramPoint;
   BlockExit() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == BlockExitKind;
   }
 };
 
 class StmtPoint : public ProgramPoint {
 public:
   StmtPoint(const Stmt *S, const void *p2, Kind k, const LocationContext *L,
             const ProgramPointTag *tag)
     : ProgramPoint(S, p2, k, L, tag) {
     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()); }
 
 protected:
   StmtPoint() = default;
 private:
   friend class ProgramPoint;
explicit FunctionExitPoint(const ReturnStmt *S,
                              const ProgramPointTag *tag = nullptr)
       : ProgramPoint(S, FunctionExitKind, LC, tag) {}
 
   const CFGBlock *getBlock() const {
     return &getLocationContext()->getCFG()->getExit();
   }
 
   const ReturnStmt *getStmt() const {
-    return reinterpret_cast<const ReturnStmt *>(getData1());
+    return reinterpret_cast<const ReturnStmt *>(getData1Ptr());
   }
 
 private:
   friend class ProgramPoint;
   FunctionExitPoint() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == FunctionExitKind;
   }

 public:
   BlockEdge(const CFGBlock *B1, const CFGBlock *B2, const LocationContext *L)
     : ProgramPoint(B1, B2, BlockEdgeKind, L) {
     assert(B1 && "BlockEdge: source block must be non-null");
     assert(B2 && "BlockEdge: destination block must be non-null");
   }
 
   const CFGBlock *getSrc() const {
-    return static_cast<const CFGBlock*>(getData1());
+    return static_cast<const CFGBlock *>(getData1Ptr());
   }
 
   const CFGBlock *getDst() const {
     return static_cast<const CFGBlock*>(getData2());
   }
 
 private:
   friend class ProgramPoint;
public:
   /// \param I The initializer.
   /// \param Loc The location of the field being initialized.
   PostInitializer(const CXXCtorInitializer *I,
                   const void *Loc,
                   const LocationContext *L)
     : 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.
   const void *getLocationValue() const {
     return getData2();
   }
 
 private:
   friend class ProgramPoint;
   PostInitializer() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == PostInitializerKind;
   }
 };
 
 /// Represents an implicit call event.
 ///
 /// The nearest statement is provided for diagnostic purposes.
 class ImplicitCallPoint : public ProgramPoint {
 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;
 private:
   friend class ProgramPoint;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() >= MinImplicitCallKind &&
            Location.getKind() <= MaxImplicitCallKind;

 /// CallEnter uses the caller's location context.
 class CallEnter : public ProgramPoint {
 public:
   CallEnter(const Stmt *stmt, const StackFrameContext *calleeCtx,
             const LocationContext *callerCtx)
     : 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 {
     return static_cast<const StackFrameContext *>(getData2());
   }
 
   /// Returns the entry block in the CFG for the entered function.
   const CFGBlock *getEntry() const {

 /// - CallExitEnd
 class CallExitBegin : public ProgramPoint {
 public:
   // CallExitBegin uses the callee's location context.
   CallExitBegin(const StackFrameContext *L, const ReturnStmt *RS)
     : ProgramPoint(RS, CallExitBeginKind, L, nullptr) { }
 
   const ReturnStmt *getReturnStmt() const {
-    return static_cast<const ReturnStmt *>(getData1());
+    return static_cast<const ReturnStmt *>(getData1Ptr());
   }
 
 private:
   friend class ProgramPoint;
   CallExitBegin() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == CallExitBeginKind;
   }
 };
 
 /// Represents a point when we finish the call exit sequence (for inlined call).
 /// \sa CallExitBegin
 class CallExitEnd : public ProgramPoint {
 public:
   // CallExitEnd uses the caller's location context.
   CallExitEnd(const StackFrameContext *CalleeCtx,
               const LocationContext *CallerCtx)
     : ProgramPoint(CalleeCtx, CallExitEndKind, CallerCtx, nullptr) {}
 
   const StackFrameContext *getCalleeContext() const {
-    return static_cast<const StackFrameContext *>(getData1());
+    return static_cast<const StackFrameContext *>(getData1Ptr());
   }
 
 private:
   friend class ProgramPoint;
   CallExitEnd() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == CallExitEndKind;
   }
 };
 
 /// Represents a point when we exit a loop.
 /// When this ProgramPoint is encountered we can be sure that the symbolic
 /// execution of the corresponding LoopStmt is finished on the given path.
 /// Note: It is possible to encounter a LoopExit element when we haven't even
 /// encountered the loop itself. At the current state not all loop exits will
 /// result in a LoopExit program point.
 class LoopExit : public ProgramPoint {
 public:
     LoopExit(const Stmt *LoopStmt, const LocationContext *LC)
             : ProgramPoint(LoopStmt, nullptr, LoopExitKind, LC) {}
 
     const Stmt *getLoopStmt() const {
-      return static_cast<const Stmt *>(getData1());
+      return static_cast<const Stmt *>(getData1Ptr());
     }
 
 private:
     friend class ProgramPoint;
     LoopExit() = default;
     static bool isKind(const ProgramPoint &Location) {
       return Location.getKind() == LoopExitKind;
     }
 };
 
 /// This is a meta program point, which should be skipped by all the diagnostic
 /// reasoning etc.
 class EpsilonPoint : public ProgramPoint {
 public:
   EpsilonPoint(const LocationContext *L, const void *Data1,
                const void *Data2 = nullptr,
                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;
   EpsilonPoint() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == EpsilonKind;
   }
 };

clang/include/clang/Basic/SourceLocation.h

 /// actually maintains two blocks of input buffers. One, starting at offset
 /// 0 and growing upwards, contains all buffers from this module. The other,
 /// starting at the highest possible offset and growing downwards, contains
 /// buffers of loaded modules.
 ///
 /// 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; }
   bool isMacroID() const { return (ID & MacroIDBit) != 0; }
 
   /// Return true if this is a valid SourceLocation object.
   ///
   /// Invalid SourceLocations are often used when events have no corresponding
   /// location in the source (e.g. a diagnostic is required for a command line
   /// option).
   bool isValid() const { return ID != 0; }
   bool isInvalid() const { return ID == 0; }
 
 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;
     return L;
   }
 
 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;
     return L;
   }
 
   /// When a SourceLocation itself cannot be used, this returns
   /// an (opaque) 32-bit integer encoding for it.
   ///
   /// 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;
   }
 
   /// When a SourceLocation itself cannot be used, this returns
   /// an (opaque) pointer encoding for it.
   ///
   /// This should only be passed to SourceLocation::getFromPtrEncoding, it
   /// should not be inspected directly.
   void* getPtrEncoding() const {
     // Double cast to avoid a warning "cast to pointer from integer of different
     // size".
     return (void*)(uintptr_t)getRawEncoding();
   }
 
   /// 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) {
     return Start.isValid() && Start.isFileID() && End.isValid() &&
            End.isFileID();
   }
 
   unsigned getHashValue() const;
struct DenseMapInfo<clang::FileID> {
     }
   };
 
   /// Define DenseMapInfo so that SourceLocation's can be used as keys in
   /// DenseMap and DenseSet. This trait class is eqivalent to
   /// 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) {
       return Loc.getHashValue();
     }
 
     static bool isEqual(clang::SourceLocation LHS, clang::SourceLocation RHS) {
       return LHS == RHS;
     }
   };
 
   // Allow calling FoldingSetNodeID::Add with SourceLocation object as parameter
   template <> struct FoldingSetTrait<clang::SourceLocation> {
     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

clang/include/clang/Basic/SourceManager.h

 static_assert(sizeof(FileInfo) <= sizeof(ExpansionInfo),
               "FileInfo must be no larger than ExpansionInfo.");
 
 /// This is a discriminated union of FileInfo and ExpansionInfo.
 ///
 /// 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;
   };
 
 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(); }
 
   const FileInfo &getFile() const {
     assert(isFile() && "Not a file SLocEntry!");
     return File;
   }
 
   const ExpansionInfo &getExpansion() const {
     assert(isExpansion() && "Not a macro expansion SLocEntry!");
     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;
     E.File = FI;
     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;
     new (&E.Expansion) ExpansionInfo(Expansion);
     return E;
   }
 };
 
class SourceManager : public RefCountedBase<SourceManager> {
   ///
   /// Negative FileIDs are indexes into this table. To get from ID to an index,
   /// use (-ID - 2).
   SmallVector<SrcMgr::SLocEntry, 0> LoadedSLocEntryTable;
 
   /// 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.
   ///
   /// Same indexing as LoadedSLocEntryTable.
   llvm::BitVector SLocEntryLoaded;
 
   /// An external source for source location entries.
public:
   //===--------------------------------------------------------------------===//
 
   /// Create a new FileID that represents the specified file
   /// being \#included from the specified IncludePosition.
   ///
   /// 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.
   ///
   /// This does no caching of the buffer and takes ownership of the
   /// 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.
   ///
   /// This does not take ownership of the MemoryBuffer. The memory buffer must
   /// 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
   /// new FileID for the \p SourceFile.
   FileID getOrCreateFileID(const FileEntry *SourceFile,
                            SrcMgr::CharacteristicKind FileCharacter);
 
   /// Return a new SourceLocation that encodes the
   /// fact that a token from SpellingLoc should actually be referenced from
   /// ExpansionLoc, and that it represents the expansion of a macro argument
   /// into the function-like macro body.
   SourceLocation createMacroArgExpansionLoc(SourceLocation Loc,
                                             SourceLocation ExpansionLoc,
                                             unsigned TokLength);
 
   /// 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.
   SourceLocation createTokenSplitLoc(SourceLocation SpellingLoc,
                                      SourceLocation TokenStart,
                                      SourceLocation TokenEnd);
 
   /// Retrieve the memory buffer associated with the given file.
public:
 
   /// Return the FileID for a SourceLocation.
   ///
   /// This is a very hot method that is used for all SourceManager queries
   /// that start with a SourceLocation object.  It is responsible for finding
   /// 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))
       return LastFileIDLookup;
 
     return getFileIDSlow(SLocOffset);
   }
 
public:
   SourceLocation getImmediateSpellingLoc(SourceLocation Loc) const;
 
   /// Form a SourceLocation from a FileID and Offset pair.
   SourceLocation getComposedLoc(FileID FID, unsigned Offset) const {
     auto *Entry = getSLocEntryOrNull(FID);
     if (!Entry)
       return SourceLocation();
 
-    unsigned GlobalOffset = Entry->getOffset() + Offset;
+    SourceLocation::UIntType GlobalOffset = Entry->getOffset() + Offset;
     return Entry->isFile() ? SourceLocation::getFileLoc(GlobalOffset)
                            : SourceLocation::getMacroLoc(GlobalOffset);
   }
 
   /// Decompose the specified location into a raw FileID + Offset pair.
   ///
   /// The first element is the FileID, the second is the offset from the
   /// start of the buffer of the location.
public:
   isAtEndOfImmediateMacroExpansion(SourceLocation Loc,
                                    SourceLocation *MacroEnd = nullptr) const;
 
   /// Returns true if \p Loc is inside the [\p Start, +\p Length)
   /// chunk of the source location address space.
   ///
   /// 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;
       return true;
     }
 
     return false;
   }
 
   /// Return true if both \p LHS and \p RHS are in the local source
   /// location address space or the loaded one.
   ///
   /// 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;
 
     if (LHSLoaded == RHSLoaded) {
       if (RelativeOffset)
         *RelativeOffset = RHSOffs - LHSOffs;
       return true;
     }
public:
   /// The size of the SLocEntry that \p FID represents.
   unsigned getFileIDSize(FileID FID) const;
 
   /// Given a specific FileID, returns true if \p Loc is inside that
   /// FileID chunk and sets relative offset (offset of \p Loc from beginning
   /// 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();
       return true;
     }
 
     return false;
   }
public:
   bool isBeforeInSLocAddrSpace(SourceLocation LHS, SourceLocation RHS) const {
     return isBeforeInSLocAddrSpace(LHS, RHS.getOffset());
   }
 
   /// Determines the order of a source location and a source location
   /// 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)
       return LHSOffset < RHS;
 
     return LHSLoaded;
   }
 
const SrcMgr::SLocEntry &getSLocEntry(FileID FID,
                                         bool *Invalid = nullptr) const {
     if (FID.ID == 0 || FID.ID == -1) {
       if (Invalid) *Invalid = true;
       return LocalSLocEntryTable[0];
     }
     return getSLocEntryByID(FID.ID, Invalid);
   }
 
-  unsigned getNextLocalOffset() const { return NextLocalOffset; }
+  SourceLocation::UIntType getNextLocalOffset() const {
+    return NextLocalOffset;
+  }
 
   void setExternalSLocEntrySource(ExternalSLocEntrySource *Source) {
     assert(LoadedSLocEntryTable.empty() &&
            "Invalidating existing loaded entries");
     ExternalSLocEntries = Source;
   }
 
   /// Allocate a number of loaded SLocEntries, which will be actually
   /// loaded on demand from the external source.
   ///
   /// 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 {
     return Loc.getOffset() >= CurrentLoadedOffset;
   }
 
   /// Returns true if \p Loc did not come from a PCH/Module.
   bool isLocalSourceLocation(SourceLocation Loc) const {
private:
 
   const SrcMgr::SLocEntry &
   getLoadedSLocEntryByID(int ID, bool *Invalid = nullptr) const {
     return getLoadedSLocEntry(static_cast<unsigned>(-ID - 2), Invalid);
   }
 
   /// 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;
 
     // If this is the very last entry then it does.
     if (FID.ID == -2)
       return true;
 
private:
   /// Create a new fileID for the specified ContentCache and
   /// include position.
   ///
   /// This works regardless of whether the ContentCache corresponds to a
   /// file or some other input source.
   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);
 
   /// Create a new ContentCache for the specified  memory buffer.
   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;
   SourceLocation getFileLocSlowCase(SourceLocation Loc) const;
 
   std::pair<FileID, unsigned>
   getDecomposedExpansionLocSlowCase(const SrcMgr::SLocEntry *E) const;
   std::pair<FileID, unsigned>

clang/include/clang/Lex/Preprocessor.h

private:
   /// Macros that we want to warn because they are not used at the end
   /// of the translation unit.
   ///
   /// We store just their SourceLocations instead of
   /// something like MacroInfo*. The benefit of this is that when we are
   /// 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
   /// reused for quick allocation.
   MacroArgs *MacroArgCache = nullptr;
 
   /// For each IdentifierInfo used in a \#pragma push_macro directive,
   /// we keep a MacroInfo stack used to restore the previous macro value.

clang/include/clang/Lex/Token.h

 /// compressed into a smaller form if memory footprint is important.
 ///
 /// The parser can create a special "annotation token" representing a stream of
 /// tokens that were parsed and semantically resolved, e.g.: "foo::MyClass<int>"
 /// can be represented by a single typename annotation token that carries
 /// 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
   // routine. Keeping as separate members with casts until a more beautiful fix
   // presents itself.
 
   /// 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:
   ///  Identifiers, keywords, etc:
   ///    This is an IdentifierInfo*, which contains the uniqued identifier
   ///    spelling.
   ///  Literals:  isLiteral() returns true.
   ///    This is a pointer to the start of the token in a text buffer, which

clang/include/clang/Serialization/ASTBitCodes.h

static TypeIdx fromTypeID(TypeID ID) {
     using SubmoduleID = uint32_t;
 
     /// The number of predefined submodule IDs.
     const unsigned int NUM_PREDEF_SUBMODULE_IDS = 1;
 
     /// 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;
 
       PPEntityOffset(SourceRange R, uint32_t BitOffset)
         : Begin(R.getBegin().getRawEncoding()),
           End(R.getEnd().getRawEncoding()), BitOffset(BitOffset) {}
 
       SourceLocation getBegin() const {
         return SourceLocation::getFromRawEncoding(Begin);
       }
 
       SourceLocation getEnd() const {
         return SourceLocation::getFromRawEncoding(End);
       }
     };
 
     /// 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()),
           End(R.getEnd().getRawEncoding()) { }
 
       SourceLocation getBegin() const {
         return SourceLocation::getFromRawEncoding(Begin);
       }
struct UnderalignedInt64 {
       uint64_t getBitOffset() const {
         return BitOffsetLow | (uint64_t(BitOffsetHigh) << 32);
       }
     };
 
     /// 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
       /// value in the padding affects AST hash.
       UnderalignedInt64 BitOffset;
 
       DeclOffset() = default;
       DeclOffset(SourceLocation Loc, uint64_t BitOffset,

clang/include/clang/Serialization/ASTReader.h

public:
 
   /// Read a AlignPackInfo from raw form.
   Sema::AlignPackInfo ReadAlignPackInfo(uint32_t Raw) const {
     return Sema::AlignPackInfo::getFromRawEncoding(Raw);
   }
 
   /// 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);
   }
 
   /// Translate a source location from another module file's source
   /// location space into ours.
   SourceLocation TranslateSourceLocation(ModuleFile &ModuleFile,
                                          SourceLocation Loc) const {
     if (!ModuleFile.ModuleOffsetMap.empty())
       ReadModuleOffsetMap(ModuleFile);
     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);
   }
 
   /// Read a source location.
   SourceLocation ReadSourceLocation(ModuleFile &ModuleFile,
                                     const RecordDataImpl &Record,
                                     unsigned &Idx) {
     return ReadSourceLocation(ModuleFile, Record[Idx++]);

clang/include/clang/Serialization/ASTWriter.h

private:
 
   /// An update to a Decl.
   class DeclUpdate {
     /// A DeclUpdateKind.
     unsigned Kind;
     union {
       const Decl *Dcl;
       void *Type;
-      unsigned Loc;
+      SourceLocation::UIntType Loc;
       unsigned Val;
       Module *Mod;
       const Attr *Attribute;
     };
 
   public:
     DeclUpdate(unsigned Kind) : Kind(Kind), Dcl(nullptr) {}
     DeclUpdate(unsigned Kind, const Decl *Dcl) : Kind(Kind), Dcl(Dcl) {}

clang/include/clang/Serialization/ModuleFile.h

public:
 
   /// The number of source location entries in this AST file.
   unsigned LocalNumSLocEntries = 0;
 
   /// The base ID in the source manager's view of this module.
   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].
   uint64_t SLocEntryOffsetsBase = 0;
 
   /// Offsets for all of the source location entries in the
   /// AST file.
   const uint32_t *SLocEntryOffsets = nullptr;
 
   /// SLocEntries that we're going to preload.
   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 ===
 
   /// The number of identifiers in this AST file.
   unsigned LocalNumIdentifiers = 0;
 
   /// Offsets into the identifier table data.
   ///

clang/lib/ARCMigrate/TransEmptyStatementsAndDealloc.cpp

static bool isEmptyARCMTMacroStatement(NullStmt *S,
   --I;
   SourceLocation
       AfterMacroLoc = I->getLocWithOffset(getARCMTMacroName().size());
   assert(AfterMacroLoc.isFileID());
 
   if (AfterMacroLoc == SemiLoc)
     return true;
 
-  int RelOffs = 0;
+  SourceLocation::IntType RelOffs = 0;
   if (!SM.isInSameSLocAddrSpace(AfterMacroLoc, SemiLoc, &RelOffs))
     return false;
   if (RelOffs < 0)
     return false;
 
   // We make the reasonable assumption that a semicolon after 100 characters
   // means that it is not the next token after our macro. If this assumption
   // fails it is not critical, we will just fail to clear out, e.g., an empty

clang/lib/AST/NestedNameSpecifier.cpp

LLVM_DUMP_METHOD void NestedNameSpecifier::dump(llvm::raw_ostream &OS,
   print(OS, PrintingPolicy(LO));
 }
 
 unsigned
 NestedNameSpecifierLoc::getLocalDataLength(NestedNameSpecifier *Qualifier) {
   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:
     // Nothing more to add.
     break;
 
   case NestedNameSpecifier::Identifier:
   case NestedNameSpecifier::Namespace:
   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:
   case NestedNameSpecifier::TypeSpec:
     // The "void*" that points at the TypeLoc data.
     // Note: the 'template' keyword is part of the TypeLoc.
     Length += sizeof(void *);
     break;
   }
 
   return Length;
 }
 
 unsigned
 NestedNameSpecifierLoc::getDataLength(NestedNameSpecifier *Qualifier) {
   unsigned Length = 0;
   for (; Qualifier; Qualifier = Qualifier->getPrefix())
     Length += getLocalDataLength(Qualifier);
   return Length;
 }
 
 /// 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);
 }
 
 /// Load a (possibly unaligned) pointer from a given address and
 /// offset.
 static void *LoadPointer(void *Data, unsigned Offset) {
   void *Result;
   memcpy(&Result, static_cast<char *>(Data) + Offset, sizeof(void*));
SourceRange NestedNameSpecifierLoc::getLocalSourceRange() const {
   switch (Qualifier->getKind()) {
   case NestedNameSpecifier::Global:
     return LoadSourceLocation(Data, Offset);
 
   case NestedNameSpecifier::Identifier:
   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: {
     // The "void*" that points at the TypeLoc data.
     // Note: the 'template' keyword is part of the TypeLoc.
     void *TypeData = LoadPointer(Data, Offset);
     TypeLoc TL(Qualifier->getAsType(), TypeData);
     return SourceRange(TL.getBeginLoc(),
static void Append(char *Start, char *End, char *&Buffer, unsigned &BufferSize,
   assert(Buffer && Start && End && End > Start && "Illegal memory buffer copy");
   memcpy(Buffer + BufferSize, Start, End - Start);
   BufferSize += End - Start;
 }
 
 /// 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.
 static void SavePointer(void *Ptr, char *&Buffer, unsigned &BufferSize,
                         unsigned &BufferCapacity) {
   Append(reinterpret_cast<char *>(&Ptr),
          reinterpret_cast<char *>(&Ptr) + sizeof(void *),
          Buffer, BufferSize, BufferCapacity);

clang/lib/AST/SelectorLocationsKind.cpp

static SourceLocation getStandardSelLoc(unsigned Index,
                                         SourceLocation ArgLoc,
                                         SourceLocation EndLoc) {
   unsigned NumSelArgs = Sel.getNumArgs();
   if (NumSelArgs == 0) {
     assert(Index == 0);
     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);
   }
 
   assert(Index < NumSelArgs);
   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);
 }
 
 namespace {
 
 template <typename T>

clang/lib/Basic/SourceLocation.cpp

static_assert(std::is_trivially_destructible<SourceLocation>::value,
               "SourceLocation must be trivially destructible because it is "
               "used in unions");
 
 static_assert(std::is_trivially_destructible<SourceRange>::value,
               "SourceRange must be trivially destructible because it is "
               "used in unions");
 
 unsigned SourceLocation::getHashValue() const {
-  return llvm::DenseMapInfo<unsigned>::getHashValue(ID);
+  return llvm::DenseMapInfo<UIntType>::getHashValue(ID);
 }
 
 void llvm::FoldingSetTrait<SourceLocation>::Profile(
     const SourceLocation &X, llvm::FoldingSetNodeID &ID) {
   ID.AddInteger(X.ID);
 }
 
 void SourceLocation::print(raw_ostream &OS, const SourceManager &SM)const{

clang/lib/Basic/SourceManager.cpp

if (!SLocEntryLoaded[Index]) {
                              SrcMgr::C_User, "")));
       return *FakeSLocEntryForRecovery;
     }
   }
 
   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)
     return std::make_pair(0, 0);
   LoadedSLocEntryTable.resize(LoadedSLocEntryTable.size() + NumSLocEntries);
   SLocEntryLoaded.resize(LoadedSLocEntryTable.size());
   CurrentLoadedOffset -= TotalSize;
   int ID = LoadedSLocEntryTable.size();

 
 /// Create a new FileID that represents the specified file
 /// being \#included from the specified IncludePosition.
 ///
 /// This translates NULL into standard input.
 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);
 }
 
 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));
 
   // If this is a named pipe, immediately load the buffer to ensure subsequent
   // calls to ContentCache::getSize() are accurate.
   if (IR.ContentsEntry->isNamedPipe())
     (void)IR.getBufferOrNone(Diag, getFileManager(), SourceLocation());
 
   return createFileIDImpl(IR, SourceFile.getName(), IncludePos, FileCharacter,
                           LoadedID, LoadedOffset);
 }
 
 /// Create a new FileID that represents the specified memory buffer.
 ///
 /// This does no caching of the buffer and takes ownership of the
 /// 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,
                           IncludeLoc, FileCharacter, LoadedID, LoadedOffset);
 }
 
 /// Create a new FileID that represents the specified memory buffer.
 ///
 /// This does not take ownership of the MemoryBuffer. The memory buffer must
 /// 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);
 }
 
 /// Get the FileID for \p SourceFile if it exists. Otherwise, create a
 /// new FileID for the \p SourceFile.
 FileID
 SourceManager::getOrCreateFileID(const FileEntry *SourceFile,
                                  SrcMgr::CharacteristicKind FileCharacter) {
   FileID ID = translateFile(SourceFile);
   return ID.isValid() ? ID : createFileID(SourceFile, SourceLocation(),
             FileCharacter);
 }
 
 /// createFileID - Create a new FileID for the specified ContentCache and
 /// include position.  This works regardless of whether the ContentCache
 /// corresponds to a file or some other input source.
 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;
     assert(Index < LoadedSLocEntryTable.size() && "FileID out of range");
     assert(!SLocEntryLoaded[Index] && "FileID already loaded");
     LoadedSLocEntryTable[Index] = SLocEntry::get(
         LoadedOffset, FileInfo::get(IncludePos, File, FileCharacter, Filename));
     SLocEntryLoaded[Index] = true;

 SourceManager::createMacroArgExpansionLoc(SourceLocation SpellingLoc,
                                           SourceLocation ExpansionLoc,
                                           unsigned TokLength) {
   ExpansionInfo Info = ExpansionInfo::createForMacroArg(SpellingLoc,
                                                         ExpansionLoc);
   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);
 }
 
 SourceLocation SourceManager::createTokenSplitLoc(SourceLocation Spelling,
                                                   SourceLocation TokenStart,
                                                   SourceLocation TokenEnd) {
   assert(getFileID(TokenStart) == getFileID(TokenEnd) &&
          "token spans multiple files");
   return createExpansionLocImpl(
       ExpansionInfo::createForTokenSplit(Spelling, TokenStart, TokenEnd),
       TokenEnd.getOffset() - TokenStart.getOffset());
 }
 
 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;
     assert(Index < LoadedSLocEntryTable.size() && "FileID out of range");
     assert(!SLocEntryLoaded[Index] && "FileID already loaded");
     LoadedSLocEntryTable[Index] = SLocEntry::get(LoadedOffset, Info);
     SLocEntryLoaded[Index] = true;
     return SourceLocation::getMacroLoc(LoadedOffset);

 // SourceLocation manipulation methods.
 //===----------------------------------------------------------------------===//
 
 /// Return the FileID for a SourceLocation.
 ///
 /// 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);
 
   // Now it is time to search for the correct file. See where the SLocOffset
   // sits in the global view and consult local or loaded buffers for it.
   if (SLocOffset < NextLocalOffset)
     return getFileIDLocal(SLocOffset);
   return getFileIDLoaded(SLocOffset);
 }
 
 /// Return the FileID for a SourceLocation with a low offset.
 ///
 /// 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
   // behavior: 1) a lot of searched FileID's are "near" the cached file
   // location or are "near" the cached expansion location. 2) others are just
   // completely random and may be a very long way away.
   //
   // To handle this, we do a linear search for up to 8 steps to catch #1 quickly
SourceManager::getFileIDLocal(SourceLocation::UIntType SLocOffset) const {
   unsigned GreaterIndex = I - LocalSLocEntryTable.begin();
   // LessIndex - This is the lower bound of the range that we're searching.
   // We know that the offset corresponding to the FileID is is less than
   // SLocOffset.
   unsigned LessIndex = 0;
   NumProbes = 0;
   while (true) {
     unsigned MiddleIndex = (GreaterIndex-LessIndex)/2+LessIndex;
-    unsigned MidOffset = getLocalSLocEntry(MiddleIndex).getOffset();
+    SourceLocation::UIntType MidOffset =
+        getLocalSLocEntry(MiddleIndex).getOffset();
 
     ++NumProbes;
 
     // If the offset of the midpoint is too large, chop the high side of the
     // range to the midpoint.
     if (MidOffset > SLocOffset) {
       GreaterIndex = MiddleIndex;
       continue;
while (true) {
     LessIndex = MiddleIndex;
   }
 }
 
 /// Return the FileID for a SourceLocation with a high offset.
 ///
 /// 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");
     return FileID();
   }
 
   // Essentially the same as the local case, but the loaded array is sorted
   // in the other direction.

 /// The size of the SLocEntry that \p FID represents.
 unsigned SourceManager::getFileIDSize(FileID FID) const {
   bool Invalid = false;
   const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &Invalid);
   if (Invalid)
     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)
     NextOffset = MaxLoadedOffset;
   else
     NextOffset = getSLocEntry(FileID::get(ID+1)).getOffset();
 
   return NextOffset - Entry.getOffset() - 1;

 
 void SourceManager::associateFileChunkWithMacroArgExp(
                                          MacroArgsMap &MacroArgsCache,
                                          FileID FID,
                                          SourceLocation SpellLoc,
                                          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
     // spelling range and if one is itself a macro argument expansion, recurse
     // and associate the file chunk that it represents.
 
     FileID SpellFID; // Current FileID in the spelling range.
     unsigned SpellRelativeOffs;
     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;
         if (SpellFIDEndOffs < SpellEndOffs)
           CurrSpellLength = SpellFIDSize - SpellRelativeOffs;
         else
           CurrSpellLength = ExpansionLength;
         associateFileChunkWithMacroArgExp(MacroArgsCache, FID,
SourceManager::getMacroArgExpandedLocation(SourceLocation Loc) const {
   MacroArgsMap::iterator I = MacroArgsCache->upper_bound(Offset);
   // In case every element in MacroArgsCache is greater than Offset we can't
   // decrement the iterator.
   if (I == MacroArgsCache->begin())
     return Loc;
 
   --I;
 
-  unsigned MacroArgBeginOffs = I->first;
+  SourceLocation::UIntType MacroArgBeginOffs = I->first;
   SourceLocation MacroArgExpandedLoc = I->second;
   if (MacroArgExpandedLoc.isValid())
     return MacroArgExpandedLoc.getLocWithOffset(Offset - MacroArgBeginOffs);
 
   return Loc;
 }
 
 std::pair<FileID, unsigned>
void SourceManager::PrintStats() const {
   llvm::errs() << "FileID scans: " << NumLinearScans << " linear, "
                << NumBinaryProbes << " binary.\n";
 }
 
 LLVM_DUMP_METHOD void SourceManager::dump() const {
   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)
       out << *NextStart << ">\n";
     else
       out << "???\?>\n";
     if (Entry.isFile()) {
       auto &FI = Entry.getFile();
LLVM_DUMP_METHOD void SourceManager::dump() const {
 
   // Dump local SLocEntries.
   for (unsigned ID = 0, NumIDs = LocalSLocEntryTable.size(); ID != NumIDs; ++ID) {
     DumpSLocEntry(ID, LocalSLocEntryTable[ID],
                   ID == NumIDs - 1 ? NextLocalOffset
                                    : 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]) {
       DumpSLocEntry(ID, LoadedSLocEntryTable[Index], NextStart);
       NextStart = LoadedSLocEntryTable[Index].getOffset();
     } else {
       NextStart = None;
     }

clang/lib/CodeGen/CGOpenMPRuntime.cpp

if (CVD->hasAttr<OMPAllocateDeclAttr>()) {
     Addr = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
         Addr, CGF.ConvertTypeForMem(Ty), getName({CVD->getName(), ".addr"}));
     if (UntiedAddr.isValid())
       CGF.EmitStoreOfScalar(Addr, UntiedAddr, /*Volatile=*/false, Ty);
 
     // 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 {
         if (!CGF.HaveInsertPoint())
           return;
         llvm::Value *Args[3];
         Args[0] = CGF.CGM.getOpenMPRuntime().getThreadID(
             CGF, SourceLocation::getFromRawEncoding(LocEncoding));

clang/lib/CodeGen/CGStmt.cpp

 /// asm call instruction.  The !srcloc MDNode contains a list of constant
 /// integers which are the source locations of the start of each line in the
 /// asm.
 static llvm::MDNode *getAsmSrcLocInfo(const StringLiteral *Str,
                                       CodeGenFunction &CGF) {
   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();
     const LangOptions &LangOpts = CGF.CGM.getLangOpts();
     unsigned StartToken = 0;
     unsigned ByteOffset = 0;
 
     // Add the location of the start of each subsequent line of the asm to the
     // MDNode.
     for (unsigned i = 0, e = StrVal.size() - 1; i != e; ++i) {
       if (StrVal[i] != '\n') continue;
       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())));
     }
   }
 
   return llvm::MDNode::get(CGF.getLLVMContext(), Locs);
 }
 
 static void UpdateAsmCallInst(llvm::CallBase &Result, bool HasSideEffect,
                               bool ReadOnly, bool ReadNone, bool NoMerge,
static void UpdateAsmCallInst(llvm::CallBase &Result, bool HasSideEffect,
 
   // Slap the source location of the inline asm into a !srcloc metadata on the
   // call.
   if (const auto *gccAsmStmt = dyn_cast<GCCAsmStmt>(&S))
     Result.setMetadata("srcloc",
                        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)));
   }
 
   if (CGF.getLangOpts().assumeFunctionsAreConvergent())
     // Conservatively, mark all inline asm blocks in CUDA or OpenCL as
     // convergent (meaning, they may call an intrinsically convergent op, such

clang/lib/CodeGen/CodeGenAction.cpp

public:
     void AssignInheritanceModel(CXXRecordDecl *RD) override {
       Gen->AssignInheritanceModel(RD);
     }
 
     void HandleVTable(CXXRecordDecl *RD) override {
       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);
     }
 
     /// Get the best possible source location to represent a diagnostic that
     /// may have associated debug info.
     const FullSourceLoc
     getBestLocationFromDebugLoc(const llvm::DiagnosticInfoWithLocationBase &D,
std::unique_ptr<PPCallbacks> Callbacks =
                                             CI.getPreprocessor());
     CI.getPreprocessor().addPPCallbacks(std::move(Callbacks));
   }
 
   return std::move(Result);
 }
 
 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);
   unsigned DiagID;
   switch (SM.getKind()) {
   case llvm::SourceMgr::DK_Error:
     DiagID = diag::err_fe_inline_asm;
     break;

clang/lib/CodeGen/CoverageMappingGen.cpp

SourceLocation getPreciseTokenLocEnd(SourceLocation Loc) {
     unsigned TokLen =
         Lexer::MeasureTokenLength(SM.getSpellingLoc(Loc), SM, LangOpts);
     return Loc.getLocWithOffset(TokLen);
   }
 
   /// 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));
   }
 
   /// Return the end location of an included file or expanded macro.
   SourceLocation getEndOfFileOrMacro(SourceLocation Loc) {
     if (Loc.isMacroID())
       return Loc.getLocWithOffset(SM.getFileIDSize(SM.getFileID(Loc)) -
                                   SM.getFileOffset(Loc));

clang/lib/Format/FormatTokenLexer.cpp

FormatToken *FormatTokenLexer::getNextToken() {
   if (StateStack.top() == LexerState::TOKEN_STASHED) {
     StateStack.pop();
     return getStashedToken();
   }
 
   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;
 
   // Consume and record whitespace until we find a significant token.
   unsigned WhitespaceLength = TrailingWhitespace;
   while (FormatTok->Tok.is(tok::unknown)) {
     StringRef Text = FormatTok->TokenText;
     auto EscapesNewline = [&](int pos) {

clang/lib/Lex/Lexer.cpp

static SourceLocation getBeginningOfFileToken(SourceLocation Loc,
   // Back up from the current location until we hit the beginning of a line
   // (or the buffer). We'll relex from that point.
   const char *StrData = Buffer.data() + LocInfo.second;
   const char *LexStart = findBeginningOfLine(Buffer, LocInfo.second);
   if (!LexStart || LexStart == StrData)
     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);
 
   // Lex tokens until we find the token that contains the source location.
   Token TheTok;
   do {
     TheLexer.LexFromRawLexer(TheTok);
SourceLocation Lexer::GetBeginningOfToken(SourceLocation Loc,
 
   SourceLocation FileLoc = SM.getSpellingLoc(Loc);
   SourceLocation BeginFileLoc = getBeginningOfFileToken(FileLoc, SM, LangOpts);
   std::pair<FileID, unsigned> FileLocInfo = SM.getDecomposedLoc(FileLoc);
   std::pair<FileID, unsigned> BeginFileLocInfo =
       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 {
 
 enum PreambleDirectiveKind {
   PDK_Skipped,
   PDK_Unknown
 };
 
 } // namespace
 
 PreambleBounds Lexer::ComputePreamble(StringRef Buffer,
                                       const LangOptions &LangOpts,
                                       unsigned MaxLines) {
   // 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());
   TheLexer.SetCommentRetentionState(true);
 
   bool InPreprocessorDirective = false;
   Token TheTok;
   SourceLocation ActiveCommentLoc;
PreambleBounds Lexer::ComputePreamble(StringRef Buffer,
   } while (true);
 
   SourceLocation End;
   if (ActiveCommentLoc.isValid())
     End = ActiveCommentLoc; // don't truncate a decl comment.
   else
     End = TheTok.getLocation();
 
-  return PreambleBounds(End.getRawEncoding() - FileLoc.getRawEncoding(),
-                        TheTok.isAtStartOfLine());
+  return PreambleBounds(
+      (unsigned)(End.getRawEncoding() - FileLoc.getRawEncoding()),
 }
 
 unsigned Lexer::getTokenPrefixLength(SourceLocation TokStart, unsigned CharNo,
                                      const SourceManager &SM,
                                      const LangOptions &LangOpts) {
   // Figure out how many physical characters away the specified expansion
   // character is.  This needs to take into consideration newlines and
   // trigraphs.

clang/lib/Lex/ModuleMap.cpp

enum TokenKind {
       IntegerLiteral,
       TextualKeyword,
       LBrace,
       RBrace,
       LSquare,
       RSquare
     } Kind;
 
-    unsigned Location;
+    SourceLocation::UIntType Location;
     unsigned StringLength;
     union {
       // If Kind != IntegerLiteral.
       const char *StringData;
 
       // If Kind == IntegerLiteral.
       uint64_t IntegerValue;
     };

clang/lib/Lex/PPCaching.cpp

bool Preprocessor::IsPreviousCachedToken(const Token &Tok) const {
   // There's currently no cached token...
   if (!CachedLexPos)
     return false;
 
   const Token LastCachedTok = CachedTokens[CachedLexPos - 1];
   if (LastCachedTok.getKind() != Tok.getKind())
     return false;
 
-  int RelOffset = 0;
+  SourceLocation::IntType RelOffset = 0;
   if ((!getSourceManager().isInSameSLocAddrSpace(
           Tok.getLocation(), getLastCachedTokenLocation(), &RelOffset)) ||
       RelOffset)
     return false;
 
   return true;
 }
 
 void Preprocessor::ReplacePreviousCachedToken(ArrayRef<Token> NewToks) {
   assert(CachedLexPos != 0 && "Expected to have some cached tokens");
   CachedTokens.insert(CachedTokens.begin() + CachedLexPos - 1, NewToks.begin(),
                       NewToks.end());
   CachedTokens.erase(CachedTokens.begin() + CachedLexPos - 1 + NewToks.size());
   CachedLexPos += NewToks.size() - 1;
 }

clang/lib/Lex/TokenLexer.cpp

TokenLexer::getExpansionLocForMacroDefLoc(SourceLocation loc) const {
   assert(ExpandLocStart.isValid() && MacroExpansionStart.isValid() &&
          "Not appropriate for token streams");
   assert(loc.isValid() && loc.isFileID());
 
   SourceManager &SM = PP.getSourceManager();
   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);
 }
 
 /// Finds the tokens that are consecutive (from the same FileID)
 /// creates a single SLocEntry, and assigns SourceLocations to each token that
 /// point to that SLocEntry. e.g for
 ///   assert(foo == bar);
static void updateConsecutiveMacroArgTokens(SourceManager &SM,
   // on the relative offset.
 
   Token *NextTok = begin_tokens + 1;
   for (; NextTok < end_tokens; ++NextTok) {
     SourceLocation NextLoc = NextTok->getLocation();
     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
     // "characters" away.
     if (RelOffs < 0 || RelOffs > 50)
       break;
 
     if (CurLoc.isMacroID() && !SM.isWrittenInSameFile(CurLoc, NextLoc))
       break; // Token from a different macro.
 
     CurLoc = NextLoc;
   }
 
   // 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 =
       SM.createMacroArgExpansionLoc(FirstLoc, InstLoc,FullLength);
 
   // Change the location of the tokens from the spelling location to the new
   // 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));
   }
 }
 
 /// Creates SLocEntries and updates the locations of macro argument
 /// tokens to their new expanded locations.
 ///

clang/lib/Parse/ParseStmtAsm.cpp

ClangAsmParserCallback::translateLocation(const llvm::SourceMgr &LSM,
 
   // 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);
+    Loc = Loc.getLocWithOffset((int)(Offset - TokOffset));
   }
   return Loc;
 }
 
 void ClangAsmParserCallback::handleDiagnostic(const llvm::SMDiagnostic &D) {
   const llvm::SourceMgr &LSM = *D.getSourceMgr();
   SourceLocation Loc = translateLocation(LSM, D.getLoc());
   TheParser.Diag(Loc, diag::err_inline_ms_asm_parsing) << D.getMessage();
TempSrcMgr.setDiagHandler(ClangAsmParserCallback::DiagHandlerCallback,
                             &Callback);
 
   unsigned NumOutputs;
   unsigned NumInputs;
   std::string AsmStringIR;
   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();
 
   // Filter out "fpsw" and "mxcsr". They aren't valid GCC asm clobber
   // constraints. Clang always adds fpsr to the clobber list anyway.
   llvm::erase_if(Clobbers, [](const std::string &C) {
     return C == "fpsr" || C == "mxcsr";

clang/lib/Serialization/ASTReader.cpp

bool ASTReader::ReadSLocEntry(int ID) {
   if (llvm::Error Err = F->SLocEntryCursor.JumpToBit(
           F->SLocEntryOffsetsBase +
           F->SLocEntryOffsets[ID - F->SLocEntryBaseID])) {
     Error(std::move(Err));
     return true;
   }
 
   BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
-  unsigned BaseOffset = F->SLocEntryBaseOffset;
+  SourceLocation::UIntType BaseOffset = F->SLocEntryBaseOffset;
 
   ++NumSLocEntriesRead;
   Expected<llvm::BitstreamEntry> MaybeEntry = SLocEntryCursor.advance();
   if (!MaybeEntry) {
     Error(MaybeEntry.takeError());
     return true;
   }
   llvm::BitstreamEntry Entry = MaybeEntry.get();
while (true) {
     case FILE_SORTED_DECLS:
       F.FileSortedDecls = (const DeclID *)Blob.data();
       F.NumFileSortedDecls = Record[0];
       break;
 
     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,
                                               SLocSpaceSize);
       if (!F.SLocEntryBaseID) {
         Error("ran out of source locations");
         break;
       }
       // Make our entry in the range map. BaseID is negative and growing, so
       // we invert it. Because we invert it, though, we need the other end of
       // the range.
       unsigned RangeStart =
           unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
       GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
       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));
 
       // Initialize the remapping table.
       // 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;
     }
 
     case MODULE_OFFSET_MAP:
       F.ModuleOffsetMap = Blob;
       break;
void ASTReader::ReadModuleOffsetMap(ModuleFile &F) const {
 
   // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
   if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
     F.SLocRemap.insert(std::make_pair(0U, 0));
     F.SLocRemap.insert(std::make_pair(2U, 1));
   }
 
   // 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);
   RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
   RemapBuilder SelectorRemap(F.SelectorRemap);
   RemapBuilder DeclRemap(F.DeclRemap);
   RemapBuilder TypeRemap(F.TypeRemap);
 
while (Data < DataEnd) {
     if (!OM) {
       std::string Msg =
           "SourceLocation remap refers to unknown module, cannot find ";
       Msg.append(std::string(Name));
       Error(Msg);
       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 =
         endian::readNext<uint32_t, little, unaligned>(Data);
     uint32_t PreprocessedEntityIDOffset =
         endian::readNext<uint32_t, little, unaligned>(Data);
     uint32_t SubmoduleIDOffset =
         endian::readNext<uint32_t, little, unaligned>(Data);
     uint32_t SelectorIDOffset =
         endian::readNext<uint32_t, little, unaligned>(Data);
     uint32_t DeclIDOffset =
         endian::readNext<uint32_t, little, unaligned>(Data);
     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,
               PreprocessedEntityRemap);
     mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
     mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
     mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
     mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);

clang/lib/Serialization/ASTWriter.cpp

if (SLoc->isFile()) {
       AddSourceLocation(Expansion.getExpansionLocStart(), Record);
       AddSourceLocation(Expansion.isMacroArgExpansion()
                             ? SourceLocation()
                             : Expansion.getExpansionLocEnd(),
                         Record);
       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);
       Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv, Record);
     }
   }
 
   Stream.ExitBlock();
ASTFileSignature ASTWriter::WriteASTCore(Sema &SemaRef, StringRef isysroot,
 
   if (Chain) {
     // Write the mapping information describing our module dependencies and how
     // each of those modules were mapped into our own offset/ID space, so that
     // the reader can build the appropriate mapping to its own offset/ID space.
     // 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
     //   submodule-id:i32
     //   selector-id:i32
     //   declaration-id:i32
     //   c++-base-specifiers-id:i32
     //   type-id:i32)
SmallString<2048> Buffer;
         using namespace llvm::support;
 
         endian::Writer LE(Out, little);
         LE.write<uint8_t>(static_cast<uint8_t>(M.Kind));
         StringRef Name = M.isModule() ? M.ModuleName : M.FileName;
         LE.write<uint16_t>(Name.size());
         Out.write(Name.data(), Name.size());
 
+        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<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.
-        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");
-          if (ShouldWrite)
-            LE.write<uint32_t>(BaseID);
-          else
-            LE.write<uint32_t>(None);
+            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
         // as keys into ContinuousRangeMaps.
         writeBaseIDOrNone(M.SLocEntryBaseOffset, M.LocalNumSLocEntries);
         writeBaseIDOrNone(M.BaseIdentifierID, M.LocalNumIdentifiers);
         writeBaseIDOrNone(M.BaseMacroID, M.LocalNumMacros);
         writeBaseIDOrNone(M.BasePreprocessedEntityID,

 
 void ASTWriter::AddAlignPackInfo(const Sema::AlignPackInfo &Info,
                                  RecordDataImpl &Record) {
   uint32_t Raw = Sema::AlignPackInfo::getRawEncoding(Info);
   Record.push_back(Raw);
 }
 
 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) {
   AddSourceLocation(Range.getBegin(), Record);
   AddSourceLocation(Range.getEnd(), Record);
 }
 
 void ASTRecordWriter::AddAPFloat(const llvm::APFloat &Value) {

clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

if (EndColNo) {
     // Add in the length of the token, so that we cover multi-char tokens.
     EndColNo += Lexer::MeasureTokenLength(Range.getEnd(), SM, LangOpts)-1;
   }
 
   // Highlight the range.  Make the span tag the outermost tag for the
   // selected range.
 
   SourceLocation E =
-    InstantiationEnd.getLocWithOffset(EndColNo - OldEndColNo);
+      InstantiationEnd.getLocWithOffset((int)(EndColNo - OldEndColNo));
 
   html::HighlightRange(R, InstantiationStart, E, HighlightStart, HighlightEnd);
 }
 
 StringRef HTMLDiagnostics::generateKeyboardNavigationJavascript() {
   return R"<<<(
 <script type='text/javascript'>
 var digitMatcher = new RegExp("[0-9]+");

clang/test/CMakeLists.txt

 # Test runner infrastructure for Clang. This configures the Clang test trees
 # for use by Lit, and delegates to LLVM's lit test handlers.
 
 if (CMAKE_CFG_INTDIR STREQUAL ".")
   set(LLVM_BUILD_MODE ".")
 else ()
   set(LLVM_BUILD_MODE "%(build_mode)s")
 endif ()
 
 string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} CLANG_TOOLS_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
 
 llvm_canonicalize_cmake_booleans(
   CLANG_BUILD_EXAMPLES
   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
   LLVM_ENABLE_PER_TARGET_RUNTIME_DIR
   LLVM_ENABLE_PLUGINS
   LLVM_ENABLE_THREADS)
 
 configure_lit_site_cfg(

clang/test/Lexer/SourceLocationsOverflow.c

 // 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"
 // CHECK-NEXT:          ^
 // CHECK-NEXT: 1 error generated.
 #include "Inputs/inc1.h"
 #include "Inputs/inc1.h"
 #include "Inputs/inc1.h"

clang/test/lit.cfg.py

if lit.util.which('xmllint'):
     config.available_features.add('xmllint')
 
 if config.enable_backtrace:
     config.available_features.add('backtrace')
 
 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:
     config.available_features.add('console')
 
 lit.util.usePlatformSdkOnDarwin(config, lit_config)
 macOSSDKVersion = lit.util.findPlatformSdkVersionOnMacOS(config, lit_config)
 if macOSSDKVersion is not None:

clang/test/lit.site.cfg.py.in

 config.host_cxx = "@CMAKE_CXX_COMPILER@"
 config.llvm_use_sanitizer = "@LLVM_USE_SANITIZER@"
 config.have_zlib = @LLVM_ENABLE_ZLIB@
 config.clang_arcmt = @CLANG_ENABLE_ARCMT@
 config.clang_default_cxx_stdlib = "@CLANG_DEFAULT_CXX_STDLIB@"
 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@
 config.enable_threads = @LLVM_ENABLE_THREADS@
 config.host_arch = "@HOST_ARCH@"
 config.python_executable = "@Python3_EXECUTABLE@"
 config.use_z3_solver = lit_config.params.get('USE_Z3_SOLVER', "@USE_Z3_SOLVER@")
 config.has_plugins = @LLVM_ENABLE_PLUGINS@

clang/tools/libclang/CIndex.cpp

MemberRefVisit(const FieldDecl *D, SourceLocation L, CXCursor parent)
                    L.getPtrEncoding()) {}
   static bool classof(const VisitorJob *VJ) {
     return VJ->getKind() == VisitorJob::MemberRefVisitKind;
   }
   const FieldDecl *get() const {
     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> {
   friend class OMPClauseEnqueue;
   VisitorWorkList &WL;
   CXCursor Parent;
 
 public:
llvm::llvm_execute_on_thread(fn, user_data,
                                    : llvm::Optional<unsigned>(stack_size));
 }
 
 //===----------------------------------------------------------------------===//
 // Token-based Operations.
 //===----------------------------------------------------------------------===//
 
 /* 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) {
   switch (clang_getTokenKind(CXTok)) {
   case CXToken_Identifier:
   case CXToken_Keyword:
     // We know we have an IdentifierInfo*, so use that.
     return cxstring::createRef(
         static_cast<IdentifierInfo *>(CXTok.ptr_data)->getNameStart());
 
   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:
   case CXToken_Comment:
     break;
   }
 
   if (isNotUsableTU(TU)) {
     LOG_BAD_TU(TU);
     return cxstring::createEmpty();
   }
 
   // We have to find the starting buffer pointer the hard way, by
   // deconstructing the source location.
   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
   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;
   StringRef Buffer =
       CXXUnit->getSourceManager().getBufferData(LocInfo.first, &Invalid);
   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) {
   if (isNotUsableTU(TU)) {
     LOG_BAD_TU(TU);
     return clang_getNullLocation();
   }
 
   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
   if (!CXXUnit)
     return clang_getNullLocation();
 
   return cxloc::translateSourceLocation(
       CXXUnit->getASTContext(),
-      SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
+      SourceLocation::getFromRawEncoding(CXTok.ulint_data[0]));
 }
 
 CXSourceRange clang_getTokenExtent(CXTranslationUnit TU, CXToken CXTok) {
   if (isNotUsableTU(TU)) {
     LOG_BAD_TU(TU);
     return clang_getNullRange();
   }
 
   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
   if (!CXXUnit)
     return clang_getNullRange();
 
   return cxloc::translateSourceRange(
       CXXUnit->getASTContext(),
-      SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
+      SourceLocation::getFromRawEncoding(CXTok.ulint_data[0]));
 }
 
 static void getTokens(ASTUnit *CXXUnit, SourceRange Range,
                       SmallVectorImpl<CXToken> &CXTokens) {
   SourceManager &SourceMgr = CXXUnit->getSourceManager();
   std::pair<FileID, unsigned> BeginLocInfo =
       SourceMgr.getDecomposedSpellingLoc(Range.getBegin());
   std::pair<FileID, unsigned> EndLocInfo =
do {
     Lex.LexFromRawLexer(Tok);
     if (Tok.is(tok::eof))
       break;
 
     // Initialize the CXToken.
     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);
     previousWasAt = Tok.is(tok::at);
   } while (Lex.getBufferLocation() < EffectiveBufferEnd);
 }
 
 CXToken *clang_getToken(CXTranslationUnit TU, CXSourceLocation Location) {
class AnnotateTokensWorker {
   const CXToken &getTok(unsigned Idx) const {
     assert(Idx < NumTokens);
     return Tokens[Idx];
   }
   bool MoreTokens() const { return TokIdx < NumTokens; }
   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);
   bool annotateAndAdvanceFunctionMacroTokens(CXCursor, RangeComparisonResult,
                                              SourceRange);
 
 public:
   AnnotateTokensWorker(CXToken *tokens, CXCursor *cursors, unsigned numTokens,
CXToken &getTok(unsigned Idx) {
     return Tokens[Idx];
   }
   const CXToken &getTok(unsigned Idx) const {
     assert(Idx < NumTokens);
     return Tokens[Idx];
   }
 
   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();
   }
 };
 
 } // end anonymous namespace
 
 static CXChildVisitResult
 MarkMacroArgTokensVisitorDelegate(CXCursor cursor, CXCursor parent,
                                   CXClientData client_data) {
static void annotatePreprocessorTokens(CXTranslationUnit TU,
   // Lex tokens in raw mode until we hit the end of the range, to avoid
   // entering #includes or expanding macros.
   while (true) {
     Token Tok;
     if (lexNext(Lex, Tok, NextIdx, NumTokens))
       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()) {
       // We have found a preprocessing directive. Annotate the tokens
       // appropriately.
       //
       // FIXME: Some simple tests here could identify macro definitions and
       // #undefs, to provide specific cursor kinds for those.
if (Tok.is(tok::hash) && Tok.isAtStartOfLine()) {
             Cursors[NextIdx - 1] =
                 MakeMacroExpansionCursor(MacroDef, Tok.getLocation(), TU);
         }
       } while (!Tok.isAtStartOfLine());
 
       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);
 
       for (; TokIdx <= LastIdx; ++TokIdx)
         updateCursorAnnotation(Cursors[TokIdx], Cursor);
 
       if (finished)
         break;
for (unsigned I = 0; I != NumTokens; ++I) {
                   .Case("nonatomic", true)
                   .Case("atomic", true)
                   .Case("getter", true)
                   .Case("setter", true)
                   .Case("strong", true)
                   .Case("weak", true)
                   .Case("class", true)
                   .Default(false))
-            Tokens[I].int_data[0] = CXToken_Keyword;
+            Tokens[I].uint_data[0] = CXToken_Keyword;
         }
         continue;
       }
 
       if (Cursors[I].kind == CXCursor_ObjCInstanceMethodDecl ||
           Cursors[I].kind == CXCursor_ObjCClassMethodDecl) {
         IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data);
         if (llvm::StringSwitch<bool>(II->getName())
                 .Case("in", true)
                 .Case("out", true)
                 .Case("inout", true)
                 .Case("oneway", true)
                 .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;
       }
     }
   }
 }
 
 void clang_annotateTokens(CXTranslationUnit TU, CXToken *Tokens,
                           unsigned NumTokens, CXCursor *Cursors) {

llvm/include/llvm/IR/DiagnosticInfo.h

 
 using DiagnosticHandlerFunction = std::function<void(const DiagnosticInfo &)>;
 
 /// Diagnostic information for inline asm reporting.
 /// This is basically a message and an optional location.
 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.
   const Instruction *Instr = nullptr;
 
 public:
   /// \p MsgStr is the message to be reported to the frontend.
   /// This class does not copy \p MsgStr, therefore the reference must be valid
   /// for the whole life time of the Diagnostic.
   DiagnosticInfoInlineAsm(const Twine &MsgStr,
                           DiagnosticSeverity Severity = DS_Error)
       : DiagnosticInfo(DK_InlineAsm, Severity), MsgStr(MsgStr) {}
 
   /// \p LocCookie if non-zero gives the line number for this report.
   /// \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) {}
 
   /// \p Instr gives the original instruction that triggered the diagnostic.
   /// \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.
   /// Same for \p I.
   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; }
 
   /// \see DiagnosticInfo::print.
   void print(DiagnosticPrinter &DP) const override;
 
   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_InlineAsm;

llvm/include/llvm/IR/LLVMContext.h

#undef LLVM_FIXED_MD_KIND
   void setDiscardValueNames(bool Discard);
 
   /// Whether there is a string map for uniquing debug info
   /// identifiers across the context.  Off by default.
   bool isODRUniquingDebugTypes() const;
   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.
   using YieldCallbackTy = void (*)(LLVMContext *Context, void *OpaqueHandle);
 
   /// setInlineAsmDiagnosticHandler - This method sets a handler that is invoked
   /// when problems with inline asm are detected by the backend.  The first
   /// argument is a function pointer and the second is a context pointer that
#undef LLVM_FIXED_MD_KIND
   /// any global mutex or cannot block the execution in another LLVM context.
   void yield();
 
   /// emitError - Emit an error message to the currently installed error handler
   /// with optional location information.  This function returns, so code should
   /// 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);
 
   /// Access the object which can disable optional passes and individual
   /// optimizations at compile time.
   OptPassGate &getOptPassGate() const;
 
   /// Set the object which can disable optional passes and individual

llvm/include/llvm/MC/MCParser/MCAsmParser.h

public:
   }
 
   virtual bool lookUpType(StringRef Name, AsmTypeInfo &Info) const {
     return true;
   }
 
   /// 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,
       const MCInstPrinter *IP, MCAsmParserSemaCallback &SI) = 0;
 
   /// Emit a note at the location \p L, with the message \p Msg.
   virtual void Note(SMLoc L, const Twine &Msg, SMRange Range = None) = 0;
 

llvm/lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp

void AsmPrinter::emitInlineAsm(StringRef Str, const MCSubtargetInfo &STI,
   emitInlineAsmEnd(STI, &TAP->getSTI());
 
   if (Res && !DiagInfo->DiagHandler)
     report_fatal_error("Error parsing inline asm\n");
 }
 
 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";
 
   const char *LastEmitted = AsmStr; // One past the last character emitted.
   unsigned NumOperands = MI->getNumOperands();
 
   while (*LastEmitted) {
     switch (*LastEmitted) {
while (*LastEmitted) {
     }
     }
   }
   OS << "\n\t.att_syntax\n" << (char)0;  // null terminate string.
 }
 
 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.
   unsigned NumOperands = MI->getNumOperands();
 
   OS << '\t';
 
   while (*LastEmitted) {
void AsmPrinter::emitInlineAsm(const MachineInstr *MI) const {
   }
 
   // Emit the #APP start marker.  This has to happen even if verbose-asm isn't
   // enabled, so we use emitRawComment.
   OutStreamer->emitRawComment(MAI->getInlineAsmStart());
 
   // 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() &&
         (LocMD = MI->getOperand(i-1).getMetadata()) &&
         LocMD->getNumOperands() != 0) {
       if (const ConstantInt *CI =
               mdconst::dyn_extract<ConstantInt>(LocMD->getOperand(0))) {
         LocCookie = CI->getZExtValue();

llvm/lib/CodeGen/MachineInstr.cpp

for (const MachineOperand &MO : MI->operands()) {
 
     HashComponents.push_back(hash_value(MO));
   }
   return hash_combine_range(HashComponents.begin(), HashComponents.end());
 }
 
 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() &&
         (LocMD = getOperand(i-1).getMetadata()) &&
         LocMD->getNumOperands() != 0) {
       if (const ConstantInt *CI =
               mdconst::dyn_extract<ConstantInt>(LocMD->getOperand(0))) {
         LocCookie = CI->getZExtValue();

llvm/lib/IR/LLVMContext.cpp

void LLVMContext::diagnose(const DiagnosticInfo &DI) {
   DiagnosticPrinterRawOStream DP(errs());
   errs() << getDiagnosticMessagePrefix(DI.getSeverity()) << ": ";
   DI.print(DP);
   errs() << "\n";
   if (DI.getSeverity() == DS_Error)
     exit(1);
 }
 
-void LLVMContext::emitError(unsigned LocCookie, const Twine &ErrorStr) {
+void LLVMContext::emitError(uint64_t LocCookie, const Twine &ErrorStr) {
   diagnose(DiagnosticInfoInlineAsm(LocCookie, ErrorStr));
 }
 
 //===----------------------------------------------------------------------===//
 // Metadata Kind Uniquing
 //===----------------------------------------------------------------------===//
 
 /// Return a unique non-zero ID for the specified metadata kind.

llvm/lib/MC/MCParser/AsmParser.cpp

public:
   void setParsingMSInlineAsm(bool V) override {
     ParsingMSInlineAsm = V;
     // When parsing MS inline asm, we must lex 0b1101 and 0ABCH as binary and
     // hex integer literals.
     Lexer.setLexMasmIntegers(V);
   }
   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,
                         MCAsmParserSemaCallback &SI) override;
 
   bool parseExpression(const MCExpr *&Res);
   bool parseExpression(const MCExpr *&Res, SMLoc &EndLoc) override;
   bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
static int rewritesSort(const AsmRewrite *AsmRewriteA,
 
   if (AsmRewritePrecedence[AsmRewriteA->Kind] <
       AsmRewritePrecedence[AsmRewriteB->Kind])
     return 1;
   llvm_unreachable("Unstable rewrite sort.");
 }
 
 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,
     const MCInstPrinter *IP, MCAsmParserSemaCallback &SI) {
   SmallVector<void *, 4> InputDecls;
   SmallVector<void *, 4> OutputDecls;
   SmallVector<bool, 4> InputDeclsAddressOf;
   SmallVector<bool, 4> OutputDeclsAddressOf;

llvm/lib/MC/MCParser/MasmParser.cpp

public:
   bool defineMacro(StringRef Name, StringRef Value) override;
 
   bool lookUpField(StringRef Name, AsmFieldInfo &Info) const override;
   bool lookUpField(StringRef Base, StringRef Member,
                    AsmFieldInfo &Info) const override;
 
   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,
                         MCAsmParserSemaCallback &SI) override;
 
   bool parseExpression(const MCExpr *&Res);
   bool parseExpression(const MCExpr *&Res, SMLoc &EndLoc) override;
   bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
if (StructIt != Structs.end()) {
     Info.Size = Structure.Size;
     return false;
   }
 
   return true;
 }
 
 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,
     const MCInstPrinter *IP, MCAsmParserSemaCallback &SI) {
   SmallVector<void *, 4> InputDecls;
   SmallVector<void *, 4> OutputDecls;
   SmallVector<bool, 4> InputDeclsAddressOf;
   SmallVector<bool, 4> OutputDeclsAddressOf;

llvm/tools/llc/llc.cpp

bool handleDiagnostics(const DiagnosticInfo &DI) override {
     errs() << LLVMContext::getDiagnosticMessagePrefix(DI.getSeverity()) << ": ";
     DI.print(DP);
     errs() << "\n";
     return true;
   }
 };
 
 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;
 
   SMD.print(nullptr, errs());
 
   // For testing purposes, we print the LocCookie here.
   if (LocCookie)