[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

1830–1831

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–114

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

3869–3870

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/include/clang/AST/DeclBase.h

class DeclContext {
   /// methods in ObjCContainerDecl should be updated appropriately.
   class ObjCContainerDeclBitfields {
     friend class ObjCContainerDecl;
     /// For the bits in DeclContextBitfields
     uint32_t : NumDeclContextBits;
 
     // Not a bitfield but this saves space.
     // Note that ObjCContainerDeclBitfields is full.
-    SourceLocation AtStart;
+    SourceLocation::LowBits AtStart_lo;
   };
 
-  /// Number of non-inherited bits in ObjCContainerDeclBitfields.
-  /// Note that here we rely on the fact that SourceLocation is 32 bits
-  /// wide. We check this with the static_assert in the ctor of DeclContext.
+  /// Number of non-inherited bits in ObjCContainerDeclBitfields. Note that
+  /// here we rely on the fact that we only keep 32 bits of the SourceLocation
+  /// in that bitfield class. We check this with the static_assert in the ctor
+  /// of DeclContext.
   enum { NumObjCContainerDeclBits = 64 - NumDeclContextBits };
 
   /// Stores the bits used by LinkageSpecDecl.
   /// If modified NumLinkageSpecDeclBits and the accessor
   /// methods in LinkageSpecDecl should be updated appropriately.
   class LinkageSpecDeclBitfields {
     friend class LinkageSpecDecl;
     /// For the bits in DeclContextBitfields.
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!");
   };
 
   /// 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
   /// outside of the DeclContext, to reduce the size of DeclContext by

clang/include/clang/AST/DeclObjC.h

 class ObjCContainerDecl : public NamedDecl, public DeclContext {
   // This class stores some data in DeclContext::ObjCContainerDeclBits
   // to save some space. Use the provided accessors to access it.
 
   // These two locations in the range mark the end of the method container.
   // The first points to the '@' token, and the second to the 'end' token.
   SourceRange AtEnd;
 
+  SourceLocation::OptionalHighBits AtStart_hi;
+
   void anchor() override;
 
 public:
   ObjCContainerDecl(Kind DK, DeclContext *DC, IdentifierInfo *Id,
                     SourceLocation nameLoc, SourceLocation atStartLoc);
 
   // Iterator access to instance/class properties.
   using prop_iterator = specific_decl_iterator<ObjCPropertyDecl>;
public:
   using PropertyDeclOrder = llvm::SmallVector<ObjCPropertyDecl *, 8>;
 
   /// This routine collects list of properties to be implemented in the class.
   /// This includes, class's and its conforming protocols' properties.
   /// Note, the superclass's properties are not included in the list.
   virtual void collectPropertiesToImplement(PropertyMap &PM,
                                             PropertyDeclOrder &PO) const {}
 
-  SourceLocation getAtStartLoc() const { return ObjCContainerDeclBits.AtStart; }
+  SourceLocation getAtStartLoc() const {
+    return SourceLocation::getFromLowHigh(ObjCContainerDeclBits.AtStart_lo,
+                                          AtStart_hi);
+  }
 
   void setAtStartLoc(SourceLocation Loc) {
-    ObjCContainerDeclBits.AtStart = Loc;
+    Loc.writeLowHigh(ObjCContainerDeclBits.AtStart_lo, AtStart_hi);
   }
 
   // Marks the end of the container.
   SourceRange getAtEndRange() const { return AtEnd; }
 
   void setAtEndRange(SourceRange atEnd) { AtEnd = atEnd; }
 
   SourceRange getSourceRange() const override LLVM_READONLY {

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/Expr.h

 /// fixed type and value class.  These don't correspond to concrete
 /// syntax; instead they're used to express operations (usually copy
 /// operations) on values whose source is generally obvious from
 /// context.
 class OpaqueValueExpr : public Expr {
   friend class ASTStmtReader;
   Expr *SourceExpr;
 
+  SourceLocation::OptionalHighBits Loc_hi;
+
 public:
   OpaqueValueExpr(SourceLocation Loc, QualType T, ExprValueKind VK,
                   ExprObjectKind OK = OK_Ordinary, Expr *SourceExpr = nullptr)
       : Expr(OpaqueValueExprClass, T, VK, OK), SourceExpr(SourceExpr) {
     setIsUnique(false);
-    OpaqueValueExprBits.Loc = Loc;
+    setLocation(Loc);
     setDependence(computeDependence(this));
   }
 
   /// Given an expression which invokes a copy constructor --- i.e.  a
   /// CXXConstructExpr, possibly wrapped in an ExprWithCleanups ---
   /// find the OpaqueValueExpr that's the source of the construction.
   static const OpaqueValueExpr *findInCopyConstruct(const Expr *expr);
 
   explicit OpaqueValueExpr(EmptyShell Empty)
     : Expr(OpaqueValueExprClass, Empty) {}
 
   /// Retrieve the location of this expression.
-  SourceLocation getLocation() const { return OpaqueValueExprBits.Loc; }
+  SourceLocation getLocation() const {
+    return SourceLocation::getFromLowHigh(OpaqueValueExprBits.Loc_lo, Loc_hi);
+  }
+  void setLocation(SourceLocation L) {
+    L.writeLowHigh(OpaqueValueExprBits.Loc_lo, Loc_hi);
+  }
 
   SourceLocation getBeginLoc() const LLVM_READONLY {
     return SourceExpr ? SourceExpr->getBeginLoc() : getLocation();
   }
   SourceLocation getEndLoc() const LLVM_READONLY {
     return SourceExpr ? SourceExpr->getEndLoc() : getLocation();
   }
   SourceLocation getExprLoc() const LLVM_READONLY {
: public Expr,
                                     TemplateArgumentLoc> {
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
   friend TrailingObjects;
 
   /// The declaration that we are referencing.
   ValueDecl *D;
 
+  /// The location of the declaration name itself.
+  SourceLocation::OptionalHighBits Loc_hi;
+
   /// Provides source/type location info for the declaration name
   /// embedded in D.
   DeclarationNameLoc DNLoc;
 
   size_t numTrailingObjects(OverloadToken<NestedNameSpecifierLoc>) const {
     return hasQualifier();
   }
 
public:
   ValueDecl *getDecl() { return D; }
   const ValueDecl *getDecl() const { return D; }
   void setDecl(ValueDecl *NewD);
 
   DeclarationNameInfo getNameInfo() const {
     return DeclarationNameInfo(getDecl()->getDeclName(), getLocation(), DNLoc);
   }
 
-  SourceLocation getLocation() const { return DeclRefExprBits.Loc; }
-  void setLocation(SourceLocation L) { DeclRefExprBits.Loc = L; }
+  SourceLocation getLocation() const {
+    return SourceLocation::getFromLowHigh(DeclRefExprBits.Loc_lo, Loc_hi);
+  }
+  void setLocation(SourceLocation L) {
+    L.writeLowHigh(DeclRefExprBits.Loc_lo, Loc_hi);
+  }
   SourceLocation getBeginLoc() const LLVM_READONLY;
   SourceLocation getEndLoc() const LLVM_READONLY;
 
   /// Determine whether this declaration reference was preceded by a
   /// C++ nested-name-specifier, e.g., \c N::foo.
   bool hasQualifier() const { return DeclRefExprBits.HasQualifier; }
 
   /// If the name was qualified, retrieves the nested-name-specifier

 
 /// [C99 6.4.2.2] - A predefined identifier such as __func__.
 class PredefinedExpr final
     : public Expr,
       private llvm::TrailingObjects<PredefinedExpr, Stmt *> {
   friend class ASTStmtReader;
   friend TrailingObjects;
 
+  /// The location of this PredefinedExpr.
+  SourceLocation::OptionalHighBits Loc_hi;
+
   // PredefinedExpr is optionally followed by a single trailing
   // "Stmt *" for the predefined identifier. It is present if and only if
   // hasFunctionName() is true and is always a "StringLiteral *".
 
 public:
   enum IdentKind {
     Func,
     Function,
public:
   /// Create an empty PredefinedExpr.
   static PredefinedExpr *CreateEmpty(const ASTContext &Ctx,
                                      bool HasFunctionName);
 
   IdentKind getIdentKind() const {
     return static_cast<IdentKind>(PredefinedExprBits.Kind);
   }
 
-  SourceLocation getLocation() const { return PredefinedExprBits.Loc; }
-  void setLocation(SourceLocation L) { PredefinedExprBits.Loc = L; }
+  SourceLocation getLocation() const {
+    return SourceLocation::getFromLowHigh(PredefinedExprBits.Loc_lo, Loc_hi);
+  }
+  void setLocation(SourceLocation L) {
+    L.writeLowHigh(PredefinedExprBits.Loc_lo, Loc_hi);
+  }
 
   StringLiteral *getFunctionName() {
     return hasFunctionName()
                ? static_cast<StringLiteral *>(*getTrailingObjects<Stmt *>())
                : nullptr;
   }
 
   const StringLiteral *getFunctionName() const {

 ///   applied to a non-complex value, the former returns its operand and the
 ///   later returns zero in the type of the operand.
 ///
 class UnaryOperator final
     : public Expr,
       private llvm::TrailingObjects<UnaryOperator, FPOptionsOverride> {
   Stmt *Val;
 
+  SourceLocation::OptionalHighBits Loc_hi;
+
   size_t numTrailingObjects(OverloadToken<FPOptionsOverride>) const {
     return UnaryOperatorBits.HasFPFeatures ? 1 : 0;
   }
 
   FPOptionsOverride &getTrailingFPFeatures() {
     assert(UnaryOperatorBits.HasFPFeatures);
     return *getTrailingObjects<FPOptionsOverride>();
   }
Opcode getOpcode() const {
     return static_cast<Opcode>(UnaryOperatorBits.Opc);
   }
   void setOpcode(Opcode Opc) { UnaryOperatorBits.Opc = Opc; }
 
   Expr *getSubExpr() const { return cast<Expr>(Val); }
   void setSubExpr(Expr *E) { Val = E; }
 
   /// getOperatorLoc - Return the location of the operator.
-  SourceLocation getOperatorLoc() const { return UnaryOperatorBits.Loc; }
-  void setOperatorLoc(SourceLocation L) { UnaryOperatorBits.Loc = L; }
+  SourceLocation getOperatorLoc() const {
+    return SourceLocation::getFromLowHigh(UnaryOperatorBits.Loc_lo, Loc_hi);
+  }
+  void setOperatorLoc(SourceLocation L) {
+    L.writeLowHigh(UnaryOperatorBits.Loc_lo, Loc_hi);
+  }
 
   /// Returns true if the unary operator can cause an overflow. For instance,
   ///   signed int i = INT_MAX; i++;
   ///   signed char c = CHAR_MAX; c++;
   /// Due to integer promotions, c++ is promoted to an int before the postfix
   /// increment, and the result is an int that cannot overflow. However, i++
   /// can overflow.
   bool canOverflow() const { return UnaryOperatorBits.CanOverflow; }

 // Postfix Operators.
 //===----------------------------------------------------------------------===//
 
 /// ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
 class ArraySubscriptExpr : public Expr {
   enum { LHS, RHS, END_EXPR };
   Stmt *SubExprs[END_EXPR];
 
+  SourceLocation::OptionalHighBits RBracketLoc_hi;
+
   bool lhsIsBase() const { return getRHS()->getType()->isIntegerType(); }
 
 public:
   ArraySubscriptExpr(Expr *lhs, Expr *rhs, QualType t, ExprValueKind VK,
                      ExprObjectKind OK, SourceLocation rbracketloc)
       : Expr(ArraySubscriptExprClass, t, VK, OK) {
     SubExprs[LHS] = lhs;
     SubExprs[RHS] = rhs;
-    ArrayOrMatrixSubscriptExprBits.RBracketLoc = rbracketloc;
+    setRBracketLoc(rbracketloc);
     setDependence(computeDependence(this));
   }
 
   /// Create an empty array subscript expression.
   explicit ArraySubscriptExpr(EmptyShell Shell)
     : Expr(ArraySubscriptExprClass, Shell) { }
 
   /// An array access can be written A[4] or 4[A] (both are equivalent).
public:
   const Expr *getIdx() const { return lhsIsBase() ? getRHS() : getLHS(); }
 
   SourceLocation getBeginLoc() const LLVM_READONLY {
     return getLHS()->getBeginLoc();
   }
   SourceLocation getEndLoc() const { return getRBracketLoc(); }
 
   SourceLocation getRBracketLoc() const {
-    return ArrayOrMatrixSubscriptExprBits.RBracketLoc;
+    return SourceLocation::getFromLowHigh(
+        ArrayOrMatrixSubscriptExprBits.RBracketLoc_lo, RBracketLoc_hi);
   }
   void setRBracketLoc(SourceLocation L) {
-    ArrayOrMatrixSubscriptExprBits.RBracketLoc = L;
+    L.writeLowHigh(ArrayOrMatrixSubscriptExprBits.RBracketLoc_lo,
+                   RBracketLoc_hi);
   }
 
   SourceLocation getExprLoc() const LLVM_READONLY {
     return getBase()->getExprLoc();
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ArraySubscriptExprClass;

 /// extension.
 /// MatrixSubscriptExpr can be either incomplete (only Base and RowIdx are set
 /// so far, the type is IncompleteMatrixIdx) or complete (Base, RowIdx and
 /// ColumnIdx refer to valid expressions). Incomplete matrix expressions only
 /// exist during the initial construction of the AST.
 class MatrixSubscriptExpr : public Expr {
   enum { BASE, ROW_IDX, COLUMN_IDX, END_EXPR };
   Stmt *SubExprs[END_EXPR];
+  SourceLocation::OptionalHighBits RBracketLoc_hi;
 
 public:
   MatrixSubscriptExpr(Expr *Base, Expr *RowIdx, Expr *ColumnIdx, QualType T,
                       SourceLocation RBracketLoc)
       : Expr(MatrixSubscriptExprClass, T, Base->getValueKind(),
              OK_MatrixComponent) {
     SubExprs[BASE] = Base;
     SubExprs[ROW_IDX] = RowIdx;
     SubExprs[COLUMN_IDX] = ColumnIdx;
-    ArrayOrMatrixSubscriptExprBits.RBracketLoc = RBracketLoc;
+    setRBracketLoc(RBracketLoc);
     setDependence(computeDependence(this));
   }
 
   /// Create an empty matrix subscript expression.
   explicit MatrixSubscriptExpr(EmptyShell Shell)
       : Expr(MatrixSubscriptExprClass, Shell) {}
 
   bool isIncomplete() const {
public:
 
   SourceLocation getEndLoc() const { return getRBracketLoc(); }
 
   SourceLocation getExprLoc() const LLVM_READONLY {
     return getBase()->getExprLoc();
   }
 
   SourceLocation getRBracketLoc() const {
-    return ArrayOrMatrixSubscriptExprBits.RBracketLoc;
+    return SourceLocation::getFromLowHigh(
+        ArrayOrMatrixSubscriptExprBits.RBracketLoc_lo, RBracketLoc_hi);
   }
   void setRBracketLoc(SourceLocation L) {
-    ArrayOrMatrixSubscriptExprBits.RBracketLoc = L;
+    L.writeLowHigh(ArrayOrMatrixSubscriptExprBits.RBracketLoc_lo,
+                   RBracketLoc_hi);
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == MatrixSubscriptExprClass;
   }
 
   // Iterators
   child_range children() {
class MemberExpr final
   /// MemberDecl - This is the decl being referenced by the field/member name.
   /// In X.F, this is the decl referenced by F.
   ValueDecl *MemberDecl;
 
   /// MemberDNLoc - Provides source/type location info for the
   /// declaration name embedded in MemberDecl.
   DeclarationNameLoc MemberDNLoc;
 
+  /// This is the location of the -> or . in the expression.
+  SourceLocation::OptionalHighBits OperatorLoc_hi;
+
   /// MemberLoc - This is the location of the member name.
   SourceLocation MemberLoc;
 
   size_t numTrailingObjects(OverloadToken<MemberExprNameQualifier>) const {
     return hasQualifierOrFoundDecl();
   }
 
   size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
public:
   }
 
   /// Retrieve the member declaration name info.
   DeclarationNameInfo getMemberNameInfo() const {
     return DeclarationNameInfo(MemberDecl->getDeclName(),
                                MemberLoc, MemberDNLoc);
   }
 
-  SourceLocation getOperatorLoc() const { return MemberExprBits.OperatorLoc; }
+  SourceLocation getOperatorLoc() const {
+    return SourceLocation::getFromLowHigh(MemberExprBits.OperatorLoc_lo,
+                                          OperatorLoc_hi);
+  }
+  void setOperatorLoc(SourceLocation L) {
+    L.writeLowHigh(MemberExprBits.OperatorLoc_lo, OperatorLoc_hi);
+  }
 
   bool isArrow() const { return MemberExprBits.IsArrow; }
   void setArrow(bool A) { MemberExprBits.IsArrow = A; }
 
   /// getMemberLoc - Return the location of the "member", in X->F, it is the
   /// location of 'F'.
   SourceLocation getMemberLoc() const { return MemberLoc; }
   void setMemberLoc(SourceLocation L) { MemberLoc = L; }

 /// operator resolves to a built-in operation, BinaryOperator will be
 /// used to express the computation (x and y may still be
 /// value-dependent). If either x or y is type-dependent, or if the
 /// "+" resolves to an overloaded operator, CXXOperatorCallExpr will
 /// be used to express the computation.
 class BinaryOperator : public Expr {
   enum { LHS, RHS, END_EXPR };
   Stmt *SubExprs[END_EXPR];
+  SourceLocation::OptionalHighBits OpLoc_hi;
 
 public:
   typedef BinaryOperatorKind Opcode;
 
 protected:
   size_t offsetOfTrailingStorage() const;
 
   /// Return a pointer to the trailing FPOptions

 public:
   static BinaryOperator *CreateEmpty(const ASTContext &C, bool hasFPFeatures);
 
   static BinaryOperator *Create(const ASTContext &C, Expr *lhs, Expr *rhs,
                                 Opcode opc, QualType ResTy, ExprValueKind VK,
                                 ExprObjectKind OK, SourceLocation opLoc,
                                 FPOptionsOverride FPFeatures);
   SourceLocation getExprLoc() const { return getOperatorLoc(); }
-  SourceLocation getOperatorLoc() const { return BinaryOperatorBits.OpLoc; }
-  void setOperatorLoc(SourceLocation L) { BinaryOperatorBits.OpLoc = L; }
+  SourceLocation getOperatorLoc() const {
+    return SourceLocation::getFromLowHigh(BinaryOperatorBits.OpLoc_lo,
+                                          OpLoc_hi);
+  }
+  void setOperatorLoc(SourceLocation L) {
+    L.writeLowHigh(BinaryOperatorBits.OpLoc_lo, OpLoc_hi);
+  }
 
   Opcode getOpcode() const {
     return static_cast<Opcode>(BinaryOperatorBits.Opc);
   }
   void setOpcode(Opcode Opc) { BinaryOperatorBits.Opc = Opc; }
 
   Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
   void setLHS(Expr *E) { SubExprs[LHS] = E; }
class GenericSelectionExpr final
   /// if and only if the generic selection expression is result-dependent.
   unsigned NumAssocs, ResultIndex;
   enum : unsigned {
     ResultDependentIndex = std::numeric_limits<unsigned>::max(),
     ControllingIndex = 0,
     AssocExprStartIndex = 1
   };
 
+  /// The location of the "_Generic".
+  SourceLocation::OptionalHighBits GenericLoc_hi;
+
   /// The location of the "default" and of the right parenthesis.
   SourceLocation DefaultLoc, RParenLoc;
 
   // GenericSelectionExpr is followed by several trailing objects.
   // They are (in order):
   //
   // * A single Stmt * for the controlling expression.
   // * An array of getNumAssocs() Stmt * for the association expressions.
ConstAssociationIterator Begin(getTrailingObjects<Stmt *>() +
                                    getTrailingObjects<TypeSourceInfo *>(),
                                    /*Offset=*/0, ResultIndex);
     ConstAssociationIterator End(Begin.E + NumAssocs, Begin.TSI + NumAssocs,
                                  /*Offset=*/NumAssocs, ResultIndex);
     return llvm::make_range(Begin, End);
   }
 
   SourceLocation getGenericLoc() const {
-    return GenericSelectionExprBits.GenericLoc;
+    return SourceLocation::getFromLowHigh(
+        GenericSelectionExprBits.GenericLoc_lo, GenericLoc_hi);
+  }
+  void setGenericLoc(SourceLocation L) {
+    L.writeLowHigh(GenericSelectionExprBits.GenericLoc_lo, GenericLoc_hi);
   }
   SourceLocation getDefaultLoc() const { return DefaultLoc; }
   SourceLocation getRParenLoc() const { return RParenLoc; }
   SourceLocation getBeginLoc() const { return getGenericLoc(); }
   SourceLocation getEndLoc() const { return getRParenLoc(); }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == GenericSelectionExprClass;

clang/include/clang/AST/ExprCXX.h

public:
 
   static bool classof(const Stmt *S) {
     return S->getStmtClass() == UserDefinedLiteralClass;
   }
 };
 
 /// A boolean literal, per ([C++ lex.bool] Boolean literals).
 class CXXBoolLiteralExpr : public Expr {
+  SourceLocation::OptionalHighBits Loc_hi;
+
 public:
   CXXBoolLiteralExpr(bool Val, QualType Ty, SourceLocation Loc)
       : Expr(CXXBoolLiteralExprClass, Ty, VK_RValue, OK_Ordinary) {
     CXXBoolLiteralExprBits.Value = Val;
-    CXXBoolLiteralExprBits.Loc = Loc;
+    setLocation(Loc);
     setDependence(ExprDependence::None);
   }
 
   explicit CXXBoolLiteralExpr(EmptyShell Empty)
       : Expr(CXXBoolLiteralExprClass, Empty) {}
 
   bool getValue() const { return CXXBoolLiteralExprBits.Value; }
   void setValue(bool V) { CXXBoolLiteralExprBits.Value = V; }
 
   SourceLocation getBeginLoc() const { return getLocation(); }
   SourceLocation getEndLoc() const { return getLocation(); }
 
-  SourceLocation getLocation() const { return CXXBoolLiteralExprBits.Loc; }
-  void setLocation(SourceLocation L) { CXXBoolLiteralExprBits.Loc = L; }
+  SourceLocation getLocation() const {
+    return SourceLocation::getFromLowHigh(CXXBoolLiteralExprBits.Loc_lo,
+                                          Loc_hi);
+  }
+  void setLocation(SourceLocation L) {
+    L.writeLowHigh(CXXBoolLiteralExprBits.Loc_lo, Loc_hi);
+  }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CXXBoolLiteralExprClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
 
   const_child_range children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 };
 
 /// The null pointer literal (C++11 [lex.nullptr])
 ///
 /// Introduced in C++11, the only literal of type \c nullptr_t is \c nullptr.
 class CXXNullPtrLiteralExpr : public Expr {
+  SourceLocation::OptionalHighBits Loc_hi;
+
 public:
   CXXNullPtrLiteralExpr(QualType Ty, SourceLocation Loc)
       : Expr(CXXNullPtrLiteralExprClass, Ty, VK_RValue, OK_Ordinary) {
-    CXXNullPtrLiteralExprBits.Loc = Loc;
+    setLocation(Loc);
     setDependence(ExprDependence::None);
   }
 
   explicit CXXNullPtrLiteralExpr(EmptyShell Empty)
       : Expr(CXXNullPtrLiteralExprClass, Empty) {}
 
   SourceLocation getBeginLoc() const { return getLocation(); }
   SourceLocation getEndLoc() const { return getLocation(); }
 
-  SourceLocation getLocation() const { return CXXNullPtrLiteralExprBits.Loc; }
-  void setLocation(SourceLocation L) { CXXNullPtrLiteralExprBits.Loc = L; }
+  SourceLocation getLocation() const {
+    return SourceLocation::getFromLowHigh(CXXNullPtrLiteralExprBits.Loc_lo,
+                                          Loc_hi);
+  }
+  void setLocation(SourceLocation L) {
+    L.writeLowHigh(CXXNullPtrLiteralExprBits.Loc_lo, Loc_hi);
+  }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CXXNullPtrLiteralExprClass;
   }
 
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }

 /// \code
 /// class Foo {
 /// public:
 ///   void bar();
 ///   void test() { this->bar(); }
 /// };
 /// \endcode
 class CXXThisExpr : public Expr {
+  SourceLocation::OptionalHighBits Loc_hi;
+
 public:
   CXXThisExpr(SourceLocation L, QualType Ty, bool IsImplicit)
       : Expr(CXXThisExprClass, Ty, VK_RValue, OK_Ordinary) {
     CXXThisExprBits.IsImplicit = IsImplicit;
-    CXXThisExprBits.Loc = L;
+    setLocation(L);
     setDependence(computeDependence(this));
   }
 
   CXXThisExpr(EmptyShell Empty) : Expr(CXXThisExprClass, Empty) {}
 
-  SourceLocation getLocation() const { return CXXThisExprBits.Loc; }
-  void setLocation(SourceLocation L) { CXXThisExprBits.Loc = L; }
+  SourceLocation getLocation() const {
+    return SourceLocation::getFromLowHigh(CXXThisExprBits.Loc_lo, Loc_hi);
+  }
+  void setLocation(SourceLocation L) {
+    L.writeLowHigh(CXXThisExprBits.Loc_lo, Loc_hi);
+  }
 
   SourceLocation getBeginLoc() const { return getLocation(); }
   SourceLocation getEndLoc() const { return getLocation(); }
 
   bool isImplicit() const { return CXXThisExprBits.IsImplicit; }
   void setImplicit(bool I) { CXXThisExprBits.IsImplicit = I; }
 
   static bool classof(const Stmt *T) {

 /// A C++ throw-expression (C++ [except.throw]).
 ///
 /// This handles 'throw' (for re-throwing the current exception) and
 /// 'throw' assignment-expression.  When assignment-expression isn't
 /// present, Op will be null.
 class CXXThrowExpr : public Expr {
   friend class ASTStmtReader;
 
+  /// The location of the "throw".
+  SourceLocation::OptionalHighBits ThrowLoc_hi;
+
   /// The optional expression in the throw statement.
   Stmt *Operand;
 
 public:
   // \p Ty is the void type which is used as the result type of the
   // expression. The \p Loc is the location of the throw keyword.
   // \p Operand is the expression in the throw statement, and can be
   // null if not present.
   CXXThrowExpr(Expr *Operand, QualType Ty, SourceLocation Loc,
                bool IsThrownVariableInScope)
       : Expr(CXXThrowExprClass, Ty, VK_RValue, OK_Ordinary), Operand(Operand) {
-    CXXThrowExprBits.ThrowLoc = Loc;
+    setThrowLoc(Loc);
     CXXThrowExprBits.IsThrownVariableInScope = IsThrownVariableInScope;
     setDependence(computeDependence(this));
   }
   CXXThrowExpr(EmptyShell Empty) : Expr(CXXThrowExprClass, Empty) {}
 
   const Expr *getSubExpr() const { return cast_or_null<Expr>(Operand); }
   Expr *getSubExpr() { return cast_or_null<Expr>(Operand); }
 
-  SourceLocation getThrowLoc() const { return CXXThrowExprBits.ThrowLoc; }
+  SourceLocation getThrowLoc() const {
+    return SourceLocation::getFromLowHigh(CXXThrowExprBits.ThrowLoc_lo,
+                                          ThrowLoc_hi);
+  }
+  void setThrowLoc(SourceLocation L) {
+    L.writeLowHigh(CXXThrowExprBits.ThrowLoc_lo, ThrowLoc_hi);
+  }
 
   /// Determines whether the variable thrown by this expression (if any!)
   /// is within the innermost try block.
   ///
   /// This information is required to determine whether the NRVO can apply to
   /// this variable.
   bool isThrownVariableInScope() const {
     return CXXThrowExprBits.IsThrownVariableInScope;

 /// A default argument (C++ [dcl.fct.default]).
 ///
 /// This wraps up a function call argument that was created from the
 /// corresponding parameter's default argument, when the call did not
 /// explicitly supply arguments for all of the parameters.
 class CXXDefaultArgExpr final : public Expr {
   friend class ASTStmtReader;
 
+  /// The location where the default argument expression was used.
+  SourceLocation::OptionalHighBits Loc_hi;
+
   /// The parameter whose default is being used.
   ParmVarDecl *Param;
 
   /// The context where the default argument expression was used.
   DeclContext *UsedContext;
 
   CXXDefaultArgExpr(StmtClass SC, SourceLocation Loc, ParmVarDecl *Param,
                     DeclContext *UsedContext)
       : Expr(SC,
              Param->hasUnparsedDefaultArg()
                  ? Param->getType().getNonReferenceType()
                  : Param->getDefaultArg()->getType(),
              Param->getDefaultArg()->getValueKind(),
              Param->getDefaultArg()->getObjectKind()),
         Param(Param), UsedContext(UsedContext) {
-    CXXDefaultArgExprBits.Loc = Loc;
+    setUsedLocation(Loc);
     setDependence(ExprDependence::None);
   }
 
 public:
   CXXDefaultArgExpr(EmptyShell Empty) : Expr(CXXDefaultArgExprClass, Empty) {}
 
   // \p Param is the parameter whose default argument is used by this
   // expression.
public:
   // Retrieve the actual argument to the function call.
   const Expr *getExpr() const { return getParam()->getDefaultArg(); }
   Expr *getExpr() { return getParam()->getDefaultArg(); }
 
   const DeclContext *getUsedContext() const { return UsedContext; }
   DeclContext *getUsedContext() { return UsedContext; }
 
   /// Retrieve the location where this default argument was actually used.
-  SourceLocation getUsedLocation() const { return CXXDefaultArgExprBits.Loc; }
+  SourceLocation getUsedLocation() const {
+    return SourceLocation::getFromLowHigh(CXXDefaultArgExprBits.Loc_lo, Loc_hi);
+  }
+  void setUsedLocation(SourceLocation L) {
+    L.writeLowHigh(CXXDefaultArgExprBits.Loc_lo, Loc_hi);
+  }
 
   /// Default argument expressions have no representation in the
   /// source, so they have an empty source range.
   SourceLocation getBeginLoc() const { return SourceLocation(); }
   SourceLocation getEndLoc() const { return SourceLocation(); }
 
   SourceLocation getExprLoc() const { return getUsedLocation(); }
 
class CXXDefaultInitExpr : public Expr {
   friend class ASTStmtReader;
 
   /// The field whose default is being used.
   FieldDecl *Field;
 
   /// The context where the default initializer expression was used.
   DeclContext *UsedContext;
 
+  /// The location where the default initializer expression was used.
+  SourceLocation::OptionalHighBits Loc_hi;
+
   CXXDefaultInitExpr(const ASTContext &Ctx, SourceLocation Loc,
                      FieldDecl *Field, QualType Ty, DeclContext *UsedContext);
 
   CXXDefaultInitExpr(EmptyShell Empty) : Expr(CXXDefaultInitExprClass, Empty) {}
 
 public:
   /// \p Field is the non-static data member whose default initializer is used
   /// by this expression.
Expr *getExpr() {
     return Field->getInClassInitializer();
   }
 
   const DeclContext *getUsedContext() const { return UsedContext; }
   DeclContext *getUsedContext() { return UsedContext; }
 
   /// Retrieve the location where this default initializer expression was
   /// actually used.
-  SourceLocation getUsedLocation() const { return getBeginLoc(); }
+  SourceLocation getUsedLocation() const {
+    return SourceLocation::getFromLowHigh(CXXDefaultInitExprBits.Loc_lo,
+                                          Loc_hi);
+  }
+  void setUsedLocation(SourceLocation L) {
+    L.writeLowHigh(CXXDefaultInitExprBits.Loc_lo, Loc_hi);
+  }
 
-  SourceLocation getBeginLoc() const { return CXXDefaultInitExprBits.Loc; }
-  SourceLocation getEndLoc() const { return CXXDefaultInitExprBits.Loc; }
+  SourceLocation getBeginLoc() const { return getUsedLocation(); }
+  SourceLocation getEndLoc() const { return getUsedLocation(); }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CXXDefaultInitExprClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
enum ConstructionKind {
     CK_VirtualBase,
     CK_Delegating
   };
 
 private:
   /// A pointer to the constructor which will be ultimately called.
   CXXConstructorDecl *Constructor;
 
+  SourceLocation::OptionalHighBits Loc_hi;
+
   SourceRange ParenOrBraceRange;
 
   /// The number of arguments.
   unsigned NumArgs;
 
   // We would like to stash the arguments of the constructor call after
   // CXXConstructExpr. However CXXConstructExpr is used as a base class of
   // CXXTemporaryObjectExpr which makes the use of llvm::TrailingObjects
Create(const ASTContext &Ctx, QualType Ty, SourceLocation Loc,
          ConstructionKind ConstructKind, SourceRange ParenOrBraceRange);
 
   /// Create an empty C++ construction expression.
   static CXXConstructExpr *CreateEmpty(const ASTContext &Ctx, unsigned NumArgs);
 
   /// Get the constructor that this expression will (ultimately) call.
   CXXConstructorDecl *getConstructor() const { return Constructor; }
 
-  SourceLocation getLocation() const { return CXXConstructExprBits.Loc; }
-  void setLocation(SourceLocation Loc) { CXXConstructExprBits.Loc = Loc; }
+  SourceLocation getLocation() const {
+    return SourceLocation::getFromLowHigh(CXXConstructExprBits.Loc_lo, Loc_hi);
+  }
+  void setLocation(SourceLocation L) {
+    L.writeLowHigh(CXXConstructExprBits.Loc_lo, Loc_hi);
+  }
 
   /// Whether this construction is elidable.
   bool isElidable() const { return CXXConstructExprBits.Elidable; }
   void setElidable(bool E) { CXXConstructExprBits.Elidable = E; }
 
   /// Whether the referred constructor was resolved from
   /// an overloaded set having size greater than 1.
   bool hadMultipleCandidates() const {
public:
   const_child_range children() const;
 };
 
 /// An expression "T()" which creates a value-initialized rvalue of type
 /// T, which is a non-class type.  See (C++98 [5.2.3p2]).
 class CXXScalarValueInitExpr : public Expr {
   friend class ASTStmtReader;
 
+  SourceLocation::OptionalHighBits RParenLoc_hi;
+
   TypeSourceInfo *TypeInfo;
 
 public:
   /// Create an explicitly-written scalar-value initialization
   /// expression.
   CXXScalarValueInitExpr(QualType Type, TypeSourceInfo *TypeInfo,
                          SourceLocation RParenLoc)
       : Expr(CXXScalarValueInitExprClass, Type, VK_RValue, OK_Ordinary),
         TypeInfo(TypeInfo) {
-    CXXScalarValueInitExprBits.RParenLoc = RParenLoc;
+    setRParenLoc(RParenLoc);
     setDependence(computeDependence(this));
   }
 
   explicit CXXScalarValueInitExpr(EmptyShell Shell)
       : Expr(CXXScalarValueInitExprClass, Shell) {}
 
   TypeSourceInfo *getTypeSourceInfo() const {
     return TypeInfo;
   }
 
   SourceLocation getRParenLoc() const {
-    return CXXScalarValueInitExprBits.RParenLoc;
+    return SourceLocation::getFromLowHigh(
+        CXXScalarValueInitExprBits.RParenLoc_lo, RParenLoc_hi);
+  }
+  void setRParenLoc(SourceLocation L) {
+    L.writeLowHigh(CXXScalarValueInitExprBits.RParenLoc_lo, RParenLoc_hi);
   }
 
   SourceLocation getBeginLoc() const LLVM_READONLY;
   SourceLocation getEndLoc() const { return getRParenLoc(); }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CXXScalarValueInitExprClass;
   }
public:
   }
 };
 
 /// Represents a \c delete expression for memory deallocation and
 /// destructor calls, e.g. "delete[] pArray".
 class CXXDeleteExpr : public Expr {
   friend class ASTStmtReader;
 
+  /// Location of the expression.
+  SourceLocation::OptionalHighBits Loc_hi;
+
   /// Points to the operator delete overload that is used. Could be a member.
   FunctionDecl *OperatorDelete = nullptr;
 
   /// The pointer expression to be deleted.
   Stmt *Argument = nullptr;
 
 public:
   CXXDeleteExpr(QualType Ty, bool GlobalDelete, bool ArrayForm,
                 bool ArrayFormAsWritten, bool UsualArrayDeleteWantsSize,
                 FunctionDecl *OperatorDelete, Expr *Arg, SourceLocation Loc)
       : Expr(CXXDeleteExprClass, Ty, VK_RValue, OK_Ordinary),
         OperatorDelete(OperatorDelete), Argument(Arg) {
     CXXDeleteExprBits.GlobalDelete = GlobalDelete;
     CXXDeleteExprBits.ArrayForm = ArrayForm;
     CXXDeleteExprBits.ArrayFormAsWritten = ArrayFormAsWritten;
     CXXDeleteExprBits.UsualArrayDeleteWantsSize = UsualArrayDeleteWantsSize;
-    CXXDeleteExprBits.Loc = Loc;
+    setLocation(Loc);
     setDependence(computeDependence(this));
   }
 
   explicit CXXDeleteExpr(EmptyShell Shell) : Expr(CXXDeleteExprClass, Shell) {}
 
   bool isGlobalDelete() const { return CXXDeleteExprBits.GlobalDelete; }
   bool isArrayForm() const { return CXXDeleteExprBits.ArrayForm; }
   bool isArrayFormAsWritten() const {
public:
   const Expr *getArgument() const { return cast<Expr>(Argument); }
 
   /// Retrieve the type being destroyed.
   ///
   /// If the type being destroyed is a dependent type which may or may not
   /// be a pointer, return an invalid type.
   QualType getDestroyedType() const;
 
-  SourceLocation getBeginLoc() const { return CXXDeleteExprBits.Loc; }
+  SourceLocation getLocation() const {
+    return SourceLocation::getFromLowHigh(CXXDeleteExprBits.Loc_lo, Loc_hi);
+  }
+  void setLocation(SourceLocation L) {
+    L.writeLowHigh(CXXDeleteExprBits.Loc_lo, Loc_hi);
+  }
+
+  SourceLocation getBeginLoc() const { return getLocation(); }
   SourceLocation getEndLoc() const LLVM_READONLY {
     return Argument->getEndLoc();
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CXXDeleteExprClass;
   }
 
class CXXDependentScopeMemberExpr final
   NestedNameSpecifierLoc QualifierLoc;
 
   /// The member to which this member expression refers, which
   /// can be name, overloaded operator, or destructor.
   ///
   /// FIXME: could also be a template-id
   DeclarationNameInfo MemberNameInfo;
 
+  /// The location of the '->' or '.' operator.
+  SourceLocation::OptionalHighBits OperatorLoc_hi;
+
   // CXXDependentScopeMemberExpr is followed by several trailing objects,
   // some of which optional. They are in order:
   //
   // * An optional ASTTemplateKWAndArgsInfo for the explicitly specified
   //   template keyword and arguments. Present if and only if
   //   hasTemplateKWAndArgsInfo().
   //
   // * An array of getNumTemplateArgs() TemplateArgumentLoc containing location
public:
   QualType getBaseType() const { return BaseType; }
 
   /// Determine whether this member expression used the '->'
   /// operator; otherwise, it used the '.' operator.
   bool isArrow() const { return CXXDependentScopeMemberExprBits.IsArrow; }
 
   /// Retrieve the location of the '->' or '.' operator.
   SourceLocation getOperatorLoc() const {
-    return CXXDependentScopeMemberExprBits.OperatorLoc;
+    return SourceLocation::getFromLowHigh(
+        CXXDependentScopeMemberExprBits.OperatorLoc_lo, OperatorLoc_hi);
+  }
+  void setOperatorLoc(SourceLocation L) {
+    L.writeLowHigh(CXXDependentScopeMemberExprBits.OperatorLoc_lo,
+                   OperatorLoc_hi);
   }
 
   /// Retrieve the nested-name-specifier that qualifies the member name.
   NestedNameSpecifier *getQualifier() const {
     return QualifierLoc.getNestedNameSpecifier();
   }
 
   /// Retrieve the nested-name-specifier that qualifies the member

 };
 
 /// Represents a reference to a non-type template parameter
 /// that has been substituted with a template argument.
 class SubstNonTypeTemplateParmExpr : public Expr {
   friend class ASTReader;
   friend class ASTStmtReader;
 
+  /// The location of the non-type template parameter reference.
+  SourceLocation::OptionalHighBits NameLoc_hi;
+
   /// The replaced parameter and a flag indicating if it was a reference
   /// parameter. For class NTTPs, we can't determine that based on the value
   /// category alone.
   llvm::PointerIntPair<NonTypeTemplateParmDecl*, 1, bool> ParamAndRef;
 
   /// The replacement expression.
   Stmt *Replacement;
 
   explicit SubstNonTypeTemplateParmExpr(EmptyShell Empty)
       : Expr(SubstNonTypeTemplateParmExprClass, Empty) {}
 
 public:
   SubstNonTypeTemplateParmExpr(QualType Ty, ExprValueKind ValueKind,
                                SourceLocation Loc,
                                NonTypeTemplateParmDecl *Param, bool RefParam,
                                Expr *Replacement)
       : Expr(SubstNonTypeTemplateParmExprClass, Ty, ValueKind, OK_Ordinary),
         ParamAndRef(Param, RefParam), Replacement(Replacement) {
-    SubstNonTypeTemplateParmExprBits.NameLoc = Loc;
+    setNameLoc(Loc);
     setDependence(computeDependence(this));
   }
 
   SourceLocation getNameLoc() const {
-    return SubstNonTypeTemplateParmExprBits.NameLoc;
+    return SourceLocation::getFromLowHigh(
+        SubstNonTypeTemplateParmExprBits.NameLoc_lo, NameLoc_hi);
+  }
+  void setNameLoc(SourceLocation L) {
+    L.writeLowHigh(SubstNonTypeTemplateParmExprBits.NameLoc_lo, NameLoc_hi);
   }
   SourceLocation getBeginLoc() const { return getNameLoc(); }
   SourceLocation getEndLoc() const { return getNameLoc(); }
 
   Expr *getReplacement() const { return cast<Expr>(Replacement); }
 
   NonTypeTemplateParmDecl *getParameter() const {
     return ParamAndRef.getPointer();

clang/include/clang/AST/ExprConcepts.h

class RequiresExpr final : public Expr,
     llvm::TrailingObjects<RequiresExpr, ParmVarDecl *,
                           concepts::Requirement *> {
   friend TrailingObjects;
   friend class ASTStmtReader;
 
   unsigned NumLocalParameters;
   unsigned NumRequirements;
   RequiresExprBodyDecl *Body;
+  SourceLocation::OptionalHighBits RequiresKWLoc_hi;
   SourceLocation RBraceLoc;
 
   unsigned numTrailingObjects(OverloadToken<ParmVarDecl *>) const {
     return NumLocalParameters;
   }
 
   unsigned numTrailingObjects(OverloadToken<concepts::Requirement *>) const {
     return NumRequirements;
public:
   /// The expression must not be dependent.
   bool isSatisfied() const {
     assert(!isValueDependent()
            && "isSatisfied called on a dependent RequiresExpr");
     return RequiresExprBits.IsSatisfied;
   }
 
   SourceLocation getRequiresKWLoc() const {
-    return RequiresExprBits.RequiresKWLoc;
+    return SourceLocation::getFromLowHigh(RequiresExprBits.RequiresKWLoc_lo,
+                                          RequiresKWLoc_hi);
+  }
+  void setRequiresKWLoc(SourceLocation L) {
+    L.writeLowHigh(RequiresExprBits.RequiresKWLoc_lo, RequiresKWLoc_hi);
   }
 
   SourceLocation getRBraceLoc() const { return RBraceLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == RequiresExprClass;
   }
 
   SourceLocation getBeginLoc() const LLVM_READONLY {
-    return RequiresExprBits.RequiresKWLoc;
+    return getRequiresKWLoc();
   }
   SourceLocation getEndLoc() const LLVM_READONLY {
     return RBraceLoc;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());

clang/include/clang/AST/Stmt.h

class NullStmtBitfields {
     /// True if the null statement was preceded by an empty macro, e.g:
     /// @code
     ///   #define CALL(x)
     ///   CALL(0);
     /// @endcode
     unsigned HasLeadingEmptyMacro : 1;
 
     /// The location of the semi-colon.
-    SourceLocation SemiLoc;
+    SourceLocation::LowBits SemiLoc_lo;
   };
 
   class CompoundStmtBitfields {
     friend class ASTStmtReader;
     friend class CompoundStmt;
 
     unsigned : NumStmtBits;
 
     unsigned NumStmts : 32 - NumStmtBits;
 
     /// The location of the opening "{".
-    SourceLocation LBraceLoc;
+    SourceLocation::LowBits LBraceLoc_lo;
   };
 
   class LabelStmtBitfields {
     friend class LabelStmt;
 
     unsigned : NumStmtBits;
 
-    SourceLocation IdentLoc;
+    SourceLocation::LowBits IdentLoc_lo;
   };
 
   class AttributedStmtBitfields {
     friend class ASTStmtReader;
     friend class AttributedStmt;
 
     unsigned : NumStmtBits;
 
     /// Number of attributes.
     unsigned NumAttrs : 32 - NumStmtBits;
 
     /// The location of the attribute.
-    SourceLocation AttrLoc;
+    SourceLocation::LowBits AttrLoc_lo;
   };
 
   class IfStmtBitfields {
     friend class ASTStmtReader;
     friend class IfStmt;
 
     unsigned : NumStmtBits;
 
     /// True if this if statement is a constexpr if.
     unsigned IsConstexpr : 1;
 
     /// True if this if statement has storage for an else statement.
     unsigned HasElse : 1;
 
     /// True if this if statement has storage for a variable declaration.
     unsigned HasVar : 1;
 
     /// True if this if statement has storage for an init statement.
     unsigned HasInit : 1;
 
     /// The location of the "if".
-    SourceLocation IfLoc;
+    SourceLocation::LowBits IfLoc_lo;
   };
 
   class SwitchStmtBitfields {
     friend class SwitchStmt;
 
     unsigned : NumStmtBits;
 
     /// True if the SwitchStmt has storage for an init statement.
     unsigned HasInit : 1;
 
     /// True if the SwitchStmt has storage for a condition variable.
     unsigned HasVar : 1;
 
     /// If the SwitchStmt is a switch on an enum value, records whether all
     /// the enum values were covered by CaseStmts.  The coverage information
     /// value is meant to be a hint for possible clients.
     unsigned AllEnumCasesCovered : 1;
 
     /// The location of the "switch".
-    SourceLocation SwitchLoc;
+    SourceLocation::LowBits SwitchLoc_lo;
   };
 
   class WhileStmtBitfields {
     friend class ASTStmtReader;
     friend class WhileStmt;
 
     unsigned : NumStmtBits;
 
     /// True if the WhileStmt has storage for a condition variable.
     unsigned HasVar : 1;
 
     /// The location of the "while".
-    SourceLocation WhileLoc;
+    SourceLocation::LowBits WhileLoc_lo;
   };
 
   class DoStmtBitfields {
     friend class DoStmt;
 
     unsigned : NumStmtBits;
 
     /// The location of the "do".
-    SourceLocation DoLoc;
+    SourceLocation::LowBits DoLoc_lo;
   };
 
   class ForStmtBitfields {
     friend class ForStmt;
 
     unsigned : NumStmtBits;
 
     /// The location of the "for".
-    SourceLocation ForLoc;
+    SourceLocation::LowBits ForLoc_lo;
   };
 
   class GotoStmtBitfields {
     friend class GotoStmt;
     friend class IndirectGotoStmt;
 
     unsigned : NumStmtBits;
 
     /// The location of the "goto".
-    SourceLocation GotoLoc;
+    SourceLocation::LowBits GotoLoc_lo;
   };
 
   class ContinueStmtBitfields {
     friend class ContinueStmt;
 
     unsigned : NumStmtBits;
 
     /// The location of the "continue".
-    SourceLocation ContinueLoc;
+    SourceLocation::LowBits ContinueLoc_lo;
   };
 
   class BreakStmtBitfields {
     friend class BreakStmt;
 
     unsigned : NumStmtBits;
 
     /// The location of the "break".
-    SourceLocation BreakLoc;
+    SourceLocation::LowBits BreakLoc_lo;
   };
 
   class ReturnStmtBitfields {
     friend class ReturnStmt;
 
     unsigned : NumStmtBits;
 
     /// True if this ReturnStmt has storage for an NRVO candidate.
     unsigned HasNRVOCandidate : 1;
 
     /// The location of the "return".
-    SourceLocation RetLoc;
+    SourceLocation::LowBits RetLoc_lo;
   };
 
   class SwitchCaseBitfields {
     friend class SwitchCase;
     friend class CaseStmt;
 
     unsigned : NumStmtBits;
 
     /// Used by CaseStmt to store whether it is a case statement
     /// of the form case LHS ... RHS (a GNU extension).
     unsigned CaseStmtIsGNURange : 1;
 
     /// The location of the "case" or "default" keyword.
-    SourceLocation KeywordLoc;
+    SourceLocation::LowBits KeywordLoc_lo;
   };
 
   //===--- Expression bitfields classes ---===//
 
   class ExprBitfields {
     friend class ASTStmtReader; // deserialization
     friend class AtomicExpr; // ctor
     friend class BlockDeclRefExpr; // ctor
class PredefinedExprBitfields {
     /// in PredefinedExpr::IdentKind.
     unsigned Kind : 4;
 
     /// True if this PredefinedExpr has a trailing "StringLiteral *"
     /// for the predefined identifier.
     unsigned HasFunctionName : 1;
 
     /// The location of this PredefinedExpr.
-    SourceLocation Loc;
+    SourceLocation::LowBits Loc_lo;
   };
 
   class DeclRefExprBitfields {
     friend class ASTStmtReader; // deserialization
     friend class DeclRefExpr;
 
     unsigned : NumExprBits;
 
     unsigned HasQualifier : 1;
     unsigned HasTemplateKWAndArgsInfo : 1;
     unsigned HasFoundDecl : 1;
     unsigned HadMultipleCandidates : 1;
     unsigned RefersToEnclosingVariableOrCapture : 1;
     unsigned NonOdrUseReason : 2;
 
     /// The location of the declaration name itself.
-    SourceLocation Loc;
+    SourceLocation::LowBits Loc_lo;
   };
 
 
   class FloatingLiteralBitfields {
     friend class FloatingLiteral;
 
     unsigned : NumExprBits;
 
class UnaryOperatorBitfields {
     unsigned Opc : 5;
     unsigned CanOverflow : 1;
     //
     /// This is only meaningful for operations on floating point
     /// types when additional values need to be in trailing storage.
     /// It is 0 otherwise.
     unsigned HasFPFeatures : 1;
 
-    SourceLocation Loc;
+    SourceLocation::LowBits Loc_lo;
   };
 
   class UnaryExprOrTypeTraitExprBitfields {
     friend class UnaryExprOrTypeTraitExpr;
 
     unsigned : NumExprBits;
 
     unsigned Kind : 3;
     unsigned IsType : 1; // true if operand is a type, false if an expression.
   };
 
   class ArrayOrMatrixSubscriptExprBitfields {
     friend class ArraySubscriptExpr;
     friend class MatrixSubscriptExpr;
 
     unsigned : NumExprBits;
 
-    SourceLocation RBracketLoc;
+    SourceLocation::LowBits RBracketLoc_lo;
   };
 
   class CallExprBitfields {
     friend class CallExpr;
 
     unsigned : NumExprBits;
 
     unsigned NumPreArgs : 1;
class MemberExprBitfields {
     unsigned HadMultipleCandidates : 1;
 
     /// Value of type NonOdrUseReason indicating why this MemberExpr does
     /// not constitute an odr-use of the named declaration. Meaningful only
     /// when naming a static member.
     unsigned NonOdrUseReason : 2;
 
     /// This is the location of the -> or . in the expression.
-    SourceLocation OperatorLoc;
+    SourceLocation::LowBits OperatorLoc_lo;
   };
 
   class CastExprBitfields {
     friend class CastExpr;
     friend class ImplicitCastExpr;
 
     unsigned : NumExprBits;
 
class BinaryOperatorBitfields {
 
     unsigned Opc : 6;
 
     /// This is only meaningful for operations on floating point
     /// types when additional values need to be in trailing storage.
     /// It is 0 otherwise.
     unsigned HasFPFeatures : 1;
 
-    SourceLocation OpLoc;
+    SourceLocation::LowBits OpLoc_lo;
   };
 
   class InitListExprBitfields {
     friend class InitListExpr;
 
     unsigned : NumExprBits;
 
     /// Whether this initializer list originally had a GNU array-range
protected:
 
   class GenericSelectionExprBitfields {
     friend class ASTStmtReader;
     friend class GenericSelectionExpr;
 
     unsigned : NumExprBits;
 
     /// The location of the "_Generic".
-    SourceLocation GenericLoc;
+    SourceLocation::LowBits GenericLoc_lo;
   };
 
   class PseudoObjectExprBitfields {
     friend class ASTStmtReader; // deserialization
     friend class PseudoObjectExpr;
 
     unsigned : NumExprBits;
 
class CXXBoolLiteralExprBitfields {
     friend class CXXBoolLiteralExpr;
 
     unsigned : NumExprBits;
 
     /// The value of the boolean literal.
     unsigned Value : 1;
 
     /// The location of the boolean literal.
-    SourceLocation Loc;
+    SourceLocation::LowBits Loc_lo;
   };
 
   class CXXNullPtrLiteralExprBitfields {
     friend class CXXNullPtrLiteralExpr;
 
     unsigned : NumExprBits;
 
     /// The location of the null pointer literal.
-    SourceLocation Loc;
+    SourceLocation::LowBits Loc_lo;
   };
 
   class CXXThisExprBitfields {
     friend class CXXThisExpr;
 
     unsigned : NumExprBits;
 
     /// Whether this is an implicit "this".
     unsigned IsImplicit : 1;
 
     /// The location of the "this".
-    SourceLocation Loc;
+    SourceLocation::LowBits Loc_lo;
   };
 
   class CXXThrowExprBitfields {
     friend class ASTStmtReader;
     friend class CXXThrowExpr;
 
     unsigned : NumExprBits;
 
     /// Whether the thrown variable (if any) is in scope.
     unsigned IsThrownVariableInScope : 1;
 
     /// The location of the "throw".
-    SourceLocation ThrowLoc;
+    SourceLocation::LowBits ThrowLoc_lo;
   };
 
   class CXXDefaultArgExprBitfields {
     friend class ASTStmtReader;
     friend class CXXDefaultArgExpr;
 
     unsigned : NumExprBits;
 
     /// The location where the default argument expression was used.
-    SourceLocation Loc;
+    SourceLocation::LowBits Loc_lo;
   };
 
   class CXXDefaultInitExprBitfields {
     friend class ASTStmtReader;
     friend class CXXDefaultInitExpr;
 
     unsigned : NumExprBits;
 
     /// The location where the default initializer expression was used.
-    SourceLocation Loc;
+    SourceLocation::LowBits Loc_lo;
   };
 
   class CXXScalarValueInitExprBitfields {
     friend class ASTStmtReader;
     friend class CXXScalarValueInitExpr;
 
     unsigned : NumExprBits;
 
-    SourceLocation RParenLoc;
+    SourceLocation::LowBits RParenLoc_lo;
   };
 
   class CXXNewExprBitfields {
     friend class ASTStmtReader;
     friend class ASTStmtWriter;
     friend class CXXNewExpr;
 
     unsigned : NumExprBits;
class CXXDeleteExprBitfields {
     /// while ArrayForm will be true).
     unsigned ArrayFormAsWritten : 1;
 
     /// Does the usual deallocation function for the element type require
     /// a size_t argument?
     unsigned UsualArrayDeleteWantsSize : 1;
 
     /// Location of the expression.
-    SourceLocation Loc;
+    SourceLocation::LowBits Loc_lo;
   };
 
   class TypeTraitExprBitfields {
     friend class ASTStmtReader;
     friend class ASTStmtWriter;
     friend class TypeTraitExpr;
 
     unsigned : NumExprBits;
class CXXConstructExprBitfields {
 
     unsigned Elidable : 1;
     unsigned HadMultipleCandidates : 1;
     unsigned ListInitialization : 1;
     unsigned StdInitListInitialization : 1;
     unsigned ZeroInitialization : 1;
     unsigned ConstructionKind : 3;
 
-    SourceLocation Loc;
+    SourceLocation::LowBits Loc_lo;
   };
 
   class ExprWithCleanupsBitfields {
     friend class ASTStmtReader; // deserialization
     friend class ExprWithCleanups;
 
     unsigned : NumExprBits;
 
class CXXDependentScopeMemberExprBitfields {
     /// keyword and arguments.
     unsigned HasTemplateKWAndArgsInfo : 1;
 
     /// See getFirstQualifierFoundInScope() and the comment listing
     /// the trailing objects.
     unsigned HasFirstQualifierFoundInScope : 1;
 
     /// The location of the '->' or '.' operator.
-    SourceLocation OperatorLoc;
+    SourceLocation::LowBits OperatorLoc_lo;
   };
 
   class OverloadExprBitfields {
     friend class ASTStmtReader;
     friend class OverloadExpr;
 
     unsigned : NumExprBits;
 
protected:
 
   class SubstNonTypeTemplateParmExprBitfields {
     friend class ASTStmtReader;
     friend class SubstNonTypeTemplateParmExpr;
 
     unsigned : NumExprBits;
 
     /// The location of the non-type template parameter reference.
-    SourceLocation NameLoc;
+    SourceLocation::LowBits NameLoc_lo;
   };
 
   class LambdaExprBitfields {
     friend class ASTStmtReader;
     friend class ASTStmtWriter;
     friend class LambdaExpr;
 
     unsigned : NumExprBits;
protected:
   class RequiresExprBitfields {
     friend class ASTStmtReader;
     friend class ASTStmtWriter;
     friend class RequiresExpr;
 
     unsigned : NumExprBits;
 
     unsigned IsSatisfied : 1;
-    SourceLocation RequiresKWLoc;
+    SourceLocation::LowBits RequiresKWLoc_lo;
   };
 
   //===--- C++ Coroutines TS bitfields classes ---===//
 
   class CoawaitExprBitfields {
     friend class CoawaitExpr;
 
     unsigned : NumExprBits;
class OpaqueValueExprBitfields {
     friend class OpaqueValueExpr;
 
     unsigned : NumExprBits;
 
     /// The OVE is a unique semantic reference to its source expression if this
     /// bit is set to true.
     unsigned IsUnique : 1;
 
-    SourceLocation Loc;
+    SourceLocation::LowBits Loc_lo;
   };
 
   union {
     // Same order as in StmtNodes.td.
     // Statements
     StmtBitfields StmtBits;
     NullStmtBitfields NullStmtBits;
     CompoundStmtBitfields CompoundStmtBits;

 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,
                   "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 {
public:
   reverse_decl_iterator decl_rend() {
     return reverse_decl_iterator(decl_begin());
   }
 };
 
 /// NullStmt - This is the null statement ";": C99 6.8.3p3.
 ///
 class NullStmt : public Stmt {
+  /// The location of the semi-colon.
+  SourceLocation::OptionalHighBits SemiLoc_hi;
+
 public:
   NullStmt(SourceLocation L, bool hasLeadingEmptyMacro = false)
       : Stmt(NullStmtClass) {
     NullStmtBits.HasLeadingEmptyMacro = hasLeadingEmptyMacro;
     setSemiLoc(L);
   }
 
   /// Build an empty null statement.
   explicit NullStmt(EmptyShell Empty) : Stmt(NullStmtClass, Empty) {}
 
-  SourceLocation getSemiLoc() const { return NullStmtBits.SemiLoc; }
-  void setSemiLoc(SourceLocation L) { NullStmtBits.SemiLoc = L; }
+  SourceLocation getSemiLoc() const {
+    return SourceLocation::getFromLowHigh(NullStmtBits.SemiLoc_lo, SemiLoc_hi);
+  }
+  void setSemiLoc(SourceLocation L) {
+    L.writeLowHigh(NullStmtBits.SemiLoc_lo, SemiLoc_hi);
+  }
 
   bool hasLeadingEmptyMacro() const {
     return NullStmtBits.HasLeadingEmptyMacro;
   }
 
   SourceLocation getBeginLoc() const { return getSemiLoc(); }
   SourceLocation getEndLoc() const { return getSemiLoc(); }
 

 };
 
 /// CompoundStmt - This represents a group of statements like { stmt stmt }.
 class CompoundStmt final : public Stmt,
                            private llvm::TrailingObjects<CompoundStmt, Stmt *> {
   friend class ASTStmtReader;
   friend TrailingObjects;
 
-  /// The location of the closing "}". LBraceLoc is stored in CompoundStmtBits.
+  /// The location of the opening "{".
+  SourceLocation::OptionalHighBits LBraceLoc_hi;
+
+  /// The location of the closing "}".
   SourceLocation RBraceLoc;
 
   CompoundStmt(ArrayRef<Stmt *> Stmts, SourceLocation LB, SourceLocation RB);
   explicit CompoundStmt(EmptyShell Empty) : Stmt(CompoundStmtClass, Empty) {}
 
   void setStmts(ArrayRef<Stmt *> Stmts);
 
 public:
   static CompoundStmt *Create(const ASTContext &C, ArrayRef<Stmt *> Stmts,
                               SourceLocation LB, SourceLocation RB);
 
   // Build an empty compound statement with a location.
   explicit CompoundStmt(SourceLocation Loc)
       : Stmt(CompoundStmtClass), RBraceLoc(Loc) {
     CompoundStmtBits.NumStmts = 0;
-    CompoundStmtBits.LBraceLoc = Loc;
+    setLBracLoc(Loc);
   }
 
   // Build an empty compound statement.
   static CompoundStmt *CreateEmpty(const ASTContext &C, unsigned NumStmts);
 
   bool body_empty() const { return CompoundStmtBits.NumStmts == 0; }
   unsigned size() const { return CompoundStmtBits.NumStmts; }
 
Stmt *getStmtExprResult() {
     }
     return body_back();
   }
 
   const Stmt *getStmtExprResult() const {
     return const_cast<CompoundStmt *>(this)->getStmtExprResult();
   }
 
-  SourceLocation getBeginLoc() const { return CompoundStmtBits.LBraceLoc; }
+  SourceLocation getBeginLoc() const { return getLBracLoc(); }
   SourceLocation getEndLoc() const { return RBraceLoc; }
 
-  SourceLocation getLBracLoc() const { return CompoundStmtBits.LBraceLoc; }
+  SourceLocation getLBracLoc() const {
+    return SourceLocation::getFromLowHigh(CompoundStmtBits.LBraceLoc_lo,
+                                          LBraceLoc_hi);
+  }
+  void setLBracLoc(SourceLocation L) {
+    L.writeLowHigh(CompoundStmtBits.LBraceLoc_lo, LBraceLoc_hi);
+  }
+
   SourceLocation getRBracLoc() const { return RBraceLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CompoundStmtClass;
   }
 
   // Iterators
   child_range children() { return child_range(body_begin(), body_end()); }
 
   const_child_range children() const {
     return const_child_range(body_begin(), body_end());
   }
 };
 
 // SwitchCase is the base class for CaseStmt and DefaultStmt,
 class SwitchCase : public Stmt {
 protected:
   /// The location of the ":".
   SourceLocation ColonLoc;
 
-  // The location of the "case" or "default" keyword. Stored in SwitchCaseBits.
-  // SourceLocation KeywordLoc;
+  /// The location of the "case" or "default" keyword.
+  SourceLocation::OptionalHighBits KeywordLoc_hi;
 
   /// A pointer to the following CaseStmt or DefaultStmt class,
   /// used by SwitchStmt.
   SwitchCase *NextSwitchCase = nullptr;
 
   SwitchCase(StmtClass SC, SourceLocation KWLoc, SourceLocation ColonLoc)
       : Stmt(SC), ColonLoc(ColonLoc) {
     setKeywordLoc(KWLoc);
   }
 
   SwitchCase(StmtClass SC, EmptyShell) : Stmt(SC) {}
 
 public:
   const SwitchCase *getNextSwitchCase() const { return NextSwitchCase; }
   SwitchCase *getNextSwitchCase() { return NextSwitchCase; }
   void setNextSwitchCase(SwitchCase *SC) { NextSwitchCase = SC; }
 
-  SourceLocation getKeywordLoc() const { return SwitchCaseBits.KeywordLoc; }
-  void setKeywordLoc(SourceLocation L) { SwitchCaseBits.KeywordLoc = L; }
+  SourceLocation getKeywordLoc() const {
+    return SourceLocation::getFromLowHigh(SwitchCaseBits.KeywordLoc_lo,
+                                          KeywordLoc_hi);
+  }
+  void setKeywordLoc(SourceLocation L) {
+    L.writeLowHigh(SwitchCaseBits.KeywordLoc_lo, KeywordLoc_hi);
+  }
+
   SourceLocation getColonLoc() const { return ColonLoc; }
   void setColonLoc(SourceLocation L) { ColonLoc = L; }
 
   inline Stmt *getSubStmt();
   const Stmt *getSubStmt() const {
     return const_cast<SwitchCase *>(this)->getSubStmt();
   }
 

 
 /// LabelStmt - Represents a label, which has a substatement.  For example:
 ///    foo: return;
 class LabelStmt : public ValueStmt {
   LabelDecl *TheDecl;
   Stmt *SubStmt;
   bool SideEntry = false;
 
+  SourceLocation::OptionalHighBits IdentLoc_hi;
+
 public:
   /// Build a label statement.
   LabelStmt(SourceLocation IL, LabelDecl *D, Stmt *substmt)
       : ValueStmt(LabelStmtClass), TheDecl(D), SubStmt(substmt) {
     setIdentLoc(IL);
   }
 
   /// Build an empty label statement.
   explicit LabelStmt(EmptyShell Empty) : ValueStmt(LabelStmtClass, Empty) {}
 
-  SourceLocation getIdentLoc() const { return LabelStmtBits.IdentLoc; }
-  void setIdentLoc(SourceLocation L) { LabelStmtBits.IdentLoc = L; }
+  SourceLocation getIdentLoc() const {
+    return SourceLocation::getFromLowHigh(LabelStmtBits.IdentLoc_lo,
+                                          IdentLoc_hi);
+  }
+  void setIdentLoc(SourceLocation L) {
+    L.writeLowHigh(LabelStmtBits.IdentLoc_lo, IdentLoc_hi);
+  }
 
   LabelDecl *getDecl() const { return TheDecl; }
   void setDecl(LabelDecl *D) { TheDecl = D; }
 
   const char *getName() const;
   Stmt *getSubStmt() { return SubStmt; }
 
   const Stmt *getSubStmt() const { return SubStmt; }

 /// Represents an attribute applied to a statement. For example:
 ///   [[omp::for(...)]] for (...) { ... }
 class AttributedStmt final
     : public ValueStmt,
       private llvm::TrailingObjects<AttributedStmt, const Attr *> {
   friend class ASTStmtReader;
   friend TrailingObjects;
 
+  /// The location of the attribute.
+  SourceLocation::OptionalHighBits AttrLoc_hi;
+
   Stmt *SubStmt;
 
   AttributedStmt(SourceLocation Loc, ArrayRef<const Attr *> Attrs,
                  Stmt *SubStmt)
       : ValueStmt(AttributedStmtClass), SubStmt(SubStmt) {
     AttributedStmtBits.NumAttrs = Attrs.size();
-    AttributedStmtBits.AttrLoc = Loc;
+    setAttrLoc(Loc);
     std::copy(Attrs.begin(), Attrs.end(), getAttrArrayPtr());
   }
 
   explicit AttributedStmt(EmptyShell Empty, unsigned NumAttrs)
       : ValueStmt(AttributedStmtClass, Empty) {
     AttributedStmtBits.NumAttrs = NumAttrs;
-    AttributedStmtBits.AttrLoc = SourceLocation{};
+    setAttrLoc(SourceLocation{});
     std::fill_n(getAttrArrayPtr(), NumAttrs, nullptr);
   }
 
   const Attr *const *getAttrArrayPtr() const {
     return getTrailingObjects<const Attr *>();
   }
   const Attr **getAttrArrayPtr() { return getTrailingObjects<const Attr *>(); }
 
 public:
   static AttributedStmt *Create(const ASTContext &C, SourceLocation Loc,
                                 ArrayRef<const Attr *> Attrs, Stmt *SubStmt);
 
   // Build an empty attributed statement.
   static AttributedStmt *CreateEmpty(const ASTContext &C, unsigned NumAttrs);
 
-  SourceLocation getAttrLoc() const { return AttributedStmtBits.AttrLoc; }
+  SourceLocation getAttrLoc() const {
+    return SourceLocation::getFromLowHigh(AttributedStmtBits.AttrLoc_lo,
+                                          AttrLoc_hi);
+  }
+  void setAttrLoc(SourceLocation L) {
+    L.writeLowHigh(AttributedStmtBits.AttrLoc_lo, AttrLoc_hi);
+  }
   ArrayRef<const Attr *> getAttrs() const {
     return llvm::makeArrayRef(getAttrArrayPtr(), AttributedStmtBits.NumAttrs);
   }
 
   Stmt *getSubStmt() { return SubStmt; }
   const Stmt *getSubStmt() const { return SubStmt; }
 
   SourceLocation getBeginLoc() const { return getAttrLoc(); }
class IfStmt final
   //
   // * A "Stmt *" for the else statement.
   //    Present if and only if hasElseStorage().
   //
   // * A "SourceLocation" for the location of the "else".
   //    Present if and only if hasElseStorage().
   enum { InitOffset = 0, ThenOffsetFromCond = 1, ElseOffsetFromCond = 2 };
   enum { NumMandatoryStmtPtr = 2 };
+  SourceLocation::OptionalHighBits IfLoc_hi;
   SourceLocation LParenLoc;
   SourceLocation RParenLoc;
 
   unsigned numTrailingObjects(OverloadToken<Stmt *>) const {
     return NumMandatoryStmtPtr + hasElseStorage() + hasVarStorage() +
            hasInitStorage();
   }
 
public:
   }
 
   void setInit(Stmt *Init) {
     assert(hasInitStorage() &&
            "This if statement has no storage for an init statement!");
     getTrailingObjects<Stmt *>()[initOffset()] = Init;
   }
 
-  SourceLocation getIfLoc() const { return IfStmtBits.IfLoc; }
-  void setIfLoc(SourceLocation IfLoc) { IfStmtBits.IfLoc = IfLoc; }
+  SourceLocation getIfLoc() const {
+    return SourceLocation::getFromLowHigh(IfStmtBits.IfLoc_lo, IfLoc_hi);
+  }
+  void setIfLoc(SourceLocation L) {
+    L.writeLowHigh(IfStmtBits.IfLoc_lo, IfLoc_hi);
+  }
 
   SourceLocation getElseLoc() const {
     return hasElseStorage() ? *getTrailingObjects<SourceLocation>()
                             : SourceLocation();
   }
 
   void setElseLoc(SourceLocation ElseLoc) {
     assert(hasElseStorage() &&
class SwitchStmt final : public Stmt,
   //
   // * A "Stmt *" for the condition.
   //    Always present. This is in fact an "Expr *".
   //
   // * A "Stmt *" for the body.
   //    Always present.
   enum { InitOffset = 0, BodyOffsetFromCond = 1 };
   enum { NumMandatoryStmtPtr = 2 };
+  SourceLocation::OptionalHighBits SwitchLoc_hi;
   SourceLocation LParenLoc;
   SourceLocation RParenLoc;
 
   unsigned numTrailingObjects(OverloadToken<Stmt *>) const {
     return NumMandatoryStmtPtr + hasInitStorage() + hasVarStorage();
   }
 
   unsigned initOffset() const { return InitOffset; }
return hasVarStorage() ? static_cast<DeclStmt *>(
                                  getTrailingObjects<Stmt *>()[varOffset()])
                            : nullptr;
   }
 
   SwitchCase *getSwitchCaseList() { return FirstCase; }
   const SwitchCase *getSwitchCaseList() const { return FirstCase; }
   void setSwitchCaseList(SwitchCase *SC) { FirstCase = SC; }
 
-  SourceLocation getSwitchLoc() const { return SwitchStmtBits.SwitchLoc; }
-  void setSwitchLoc(SourceLocation L) { SwitchStmtBits.SwitchLoc = L; }
+  SourceLocation getSwitchLoc() const {
+    return SourceLocation::getFromLowHigh(SwitchStmtBits.SwitchLoc_lo,
+                                          SwitchLoc_hi);
+  }
+  void setSwitchLoc(SourceLocation L) {
+    L.writeLowHigh(SwitchStmtBits.SwitchLoc_lo, SwitchLoc_hi);
+  }
   SourceLocation getLParenLoc() const { return LParenLoc; }
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
   SourceLocation getRParenLoc() const { return RParenLoc; }
   void setRParenLoc(SourceLocation Loc) { RParenLoc = Loc; }
 
   void setBody(Stmt *S, SourceLocation SL) {
     setBody(S);
     setSwitchLoc(SL);
class WhileStmt final : public Stmt,
   //    Always present. This is in fact an "Expr *".
   //
   // * A "Stmt *" for the body.
   //    Always present.
   //
   enum { VarOffset = 0, BodyOffsetFromCond = 1 };
   enum { NumMandatoryStmtPtr = 2 };
 
+  SourceLocation::OptionalHighBits WhileLoc_hi;
   SourceLocation LParenLoc, RParenLoc;
 
   unsigned varOffset() const { return VarOffset; }
   unsigned condOffset() const { return VarOffset + hasVarStorage(); }
   unsigned bodyOffset() const { return condOffset() + BodyOffsetFromCond; }
 
   unsigned numTrailingObjects(OverloadToken<Stmt *>) const {
     return NumMandatoryStmtPtr + hasVarStorage();
public:
   }
 
   const DeclStmt *getConditionVariableDeclStmt() const {
     return hasVarStorage() ? static_cast<DeclStmt *>(
                                  getTrailingObjects<Stmt *>()[varOffset()])
                            : nullptr;
   }
 
-  SourceLocation getWhileLoc() const { return WhileStmtBits.WhileLoc; }
-  void setWhileLoc(SourceLocation L) { WhileStmtBits.WhileLoc = L; }
+  SourceLocation getWhileLoc() const {
+    return SourceLocation::getFromLowHigh(WhileStmtBits.WhileLoc_lo,
+                                          WhileLoc_hi);
+  }
+  void setWhileLoc(SourceLocation L) {
+    L.writeLowHigh(WhileStmtBits.WhileLoc_lo, WhileLoc_hi);
+  }
 
   SourceLocation getLParenLoc() const { return LParenLoc; }
   void setLParenLoc(SourceLocation L) { LParenLoc = L; }
   SourceLocation getRParenLoc() const { return RParenLoc; }
   void setRParenLoc(SourceLocation L) { RParenLoc = L; }
 
   SourceLocation getBeginLoc() const { return getWhileLoc(); }
   SourceLocation getEndLoc() const LLVM_READONLY {
return const_child_range(getTrailingObjects<Stmt *>(),
                                  numTrailingObjects(OverloadToken<Stmt *>()));
   }
 };
 
 /// DoStmt - This represents a 'do/while' stmt.
 class DoStmt : public Stmt {
   enum { BODY, COND, END_EXPR };
   Stmt *SubExprs[END_EXPR];
+  SourceLocation::OptionalHighBits DoLoc_hi;
   SourceLocation WhileLoc;
   SourceLocation RParenLoc; // Location of final ')' in do stmt condition.
 
 public:
   DoStmt(Stmt *Body, Expr *Cond, SourceLocation DL, SourceLocation WL,
          SourceLocation RP)
       : Stmt(DoStmtClass), WhileLoc(WL), RParenLoc(RP) {
     setCond(Cond);
public:
   }
 
   void setCond(Expr *Cond) { SubExprs[COND] = reinterpret_cast<Stmt *>(Cond); }
 
   Stmt *getBody() { return SubExprs[BODY]; }
   const Stmt *getBody() const { return SubExprs[BODY]; }
   void setBody(Stmt *Body) { SubExprs[BODY] = Body; }
 
-  SourceLocation getDoLoc() const { return DoStmtBits.DoLoc; }
-  void setDoLoc(SourceLocation L) { DoStmtBits.DoLoc = L; }
+  SourceLocation getDoLoc() const {
+    return SourceLocation::getFromLowHigh(DoStmtBits.DoLoc_lo, DoLoc_hi);
+  }
+  void setDoLoc(SourceLocation L) {
+    L.writeLowHigh(DoStmtBits.DoLoc_lo, DoLoc_hi);
+  }
   SourceLocation getWhileLoc() const { return WhileLoc; }
   void setWhileLoc(SourceLocation L) { WhileLoc = L; }
   SourceLocation getRParenLoc() const { return RParenLoc; }
   void setRParenLoc(SourceLocation L) { RParenLoc = L; }
 
   SourceLocation getBeginLoc() const { return getDoLoc(); }
   SourceLocation getEndLoc() const { return getRParenLoc(); }
 

 };
 
 /// ForStmt - This represents a 'for (init;cond;inc)' stmt.  Note that any of
 /// the init/cond/inc parts of the ForStmt will be null if they were not
 /// specified in the source.
 class ForStmt : public Stmt {
   enum { INIT, CONDVAR, COND, INC, BODY, END_EXPR };
   Stmt* SubExprs[END_EXPR]; // SubExprs[INIT] is an expression or declstmt.
+
+  SourceLocation::OptionalHighBits ForLoc_hi;
   SourceLocation LParenLoc, RParenLoc;
 
 public:
   ForStmt(const ASTContext &C, Stmt *Init, Expr *Cond, VarDecl *condVar,
           Expr *Inc, Stmt *Body, SourceLocation FL, SourceLocation LP,
           SourceLocation RP);
 
   /// Build an empty for statement.
public:
   const Expr *getInc()  const { return reinterpret_cast<Expr*>(SubExprs[INC]); }
   const Stmt *getBody() const { return SubExprs[BODY]; }
 
   void setInit(Stmt *S) { SubExprs[INIT] = S; }
   void setCond(Expr *E) { SubExprs[COND] = reinterpret_cast<Stmt*>(E); }
   void setInc(Expr *E) { SubExprs[INC] = reinterpret_cast<Stmt*>(E); }
   void setBody(Stmt *S) { SubExprs[BODY] = S; }
 
-  SourceLocation getForLoc() const { return ForStmtBits.ForLoc; }
-  void setForLoc(SourceLocation L) { ForStmtBits.ForLoc = L; }
+  SourceLocation getForLoc() const {
+    return SourceLocation::getFromLowHigh(ForStmtBits.ForLoc_lo, ForLoc_hi);
+  }
+  void setForLoc(SourceLocation L) {
+    L.writeLowHigh(ForStmtBits.ForLoc_lo, ForLoc_hi);
+  }
   SourceLocation getLParenLoc() const { return LParenLoc; }
   void setLParenLoc(SourceLocation L) { LParenLoc = L; }
   SourceLocation getRParenLoc() const { return RParenLoc; }
   void setRParenLoc(SourceLocation L) { RParenLoc = L; }
 
   SourceLocation getBeginLoc() const { return getForLoc(); }
   SourceLocation getEndLoc() const { return getBody()->getEndLoc(); }
 
public:
   const_child_range children() const {
     return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
   }
 };
 
 /// GotoStmt - This represents a direct goto.
 class GotoStmt : public Stmt {
   LabelDecl *Label;
+  SourceLocation::OptionalHighBits GotoLoc_hi;
   SourceLocation LabelLoc;
 
 public:
   GotoStmt(LabelDecl *label, SourceLocation GL, SourceLocation LL)
       : Stmt(GotoStmtClass), Label(label), LabelLoc(LL) {
     setGotoLoc(GL);
   }
 
   /// Build an empty goto statement.
   explicit GotoStmt(EmptyShell Empty) : Stmt(GotoStmtClass, Empty) {}
 
   LabelDecl *getLabel() const { return Label; }
   void setLabel(LabelDecl *D) { Label = D; }
 
-  SourceLocation getGotoLoc() const { return GotoStmtBits.GotoLoc; }
-  void setGotoLoc(SourceLocation L) { GotoStmtBits.GotoLoc = L; }
+  SourceLocation getGotoLoc() const {
+    return SourceLocation::getFromLowHigh(GotoStmtBits.GotoLoc_lo, GotoLoc_hi);
+  }
+  void setGotoLoc(SourceLocation L) {
+    L.writeLowHigh(GotoStmtBits.GotoLoc_lo, GotoLoc_hi);
+  }
   SourceLocation getLabelLoc() const { return LabelLoc; }
   void setLabelLoc(SourceLocation L) { LabelLoc = L; }
 
   SourceLocation getBeginLoc() const { return getGotoLoc(); }
   SourceLocation getEndLoc() const { return getLabelLoc(); }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == GotoStmtClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
 
   const_child_range children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 };
 
 /// IndirectGotoStmt - This represents an indirect goto.
 class IndirectGotoStmt : public Stmt {
+  SourceLocation::OptionalHighBits GotoLoc_hi;
   SourceLocation StarLoc;
   Stmt *Target;
 
 public:
   IndirectGotoStmt(SourceLocation gotoLoc, SourceLocation starLoc, Expr *target)
       : Stmt(IndirectGotoStmtClass), StarLoc(starLoc) {
     setTarget(target);
     setGotoLoc(gotoLoc);
   }
 
   /// Build an empty indirect goto statement.
   explicit IndirectGotoStmt(EmptyShell Empty)
       : Stmt(IndirectGotoStmtClass, Empty) {}
 
-  void setGotoLoc(SourceLocation L) { GotoStmtBits.GotoLoc = L; }
-  SourceLocation getGotoLoc() const { return GotoStmtBits.GotoLoc; }
+  SourceLocation getGotoLoc() const {
+    return SourceLocation::getFromLowHigh(GotoStmtBits.GotoLoc_lo, GotoLoc_hi);
+  }
+  void setGotoLoc(SourceLocation L) {
+    L.writeLowHigh(GotoStmtBits.GotoLoc_lo, GotoLoc_hi);
+  }
   void setStarLoc(SourceLocation L) { StarLoc = L; }
   SourceLocation getStarLoc() const { return StarLoc; }
 
   Expr *getTarget() { return reinterpret_cast<Expr *>(Target); }
   const Expr *getTarget() const {
     return reinterpret_cast<const Expr *>(Target);
   }
   void setTarget(Expr *E) { Target = reinterpret_cast<Stmt *>(E); }
public:
 
   const_child_range children() const {
     return const_child_range(&Target, &Target + 1);
   }
 };
 
 /// ContinueStmt - This represents a continue.
 class ContinueStmt : public Stmt {
+  /// The location of the "continue".
+  SourceLocation::OptionalHighBits ContinueLoc_hi;
+
 public:
   ContinueStmt(SourceLocation CL) : Stmt(ContinueStmtClass) {
     setContinueLoc(CL);
   }
 
   /// Build an empty continue statement.
   explicit ContinueStmt(EmptyShell Empty) : Stmt(ContinueStmtClass, Empty) {}
 
-  SourceLocation getContinueLoc() const { return ContinueStmtBits.ContinueLoc; }
-  void setContinueLoc(SourceLocation L) { ContinueStmtBits.ContinueLoc = L; }
+  SourceLocation getContinueLoc() const {
+    return SourceLocation::getFromLowHigh(ContinueStmtBits.ContinueLoc_lo,
+                                          ContinueLoc_hi);
+  }
+  void setContinueLoc(SourceLocation L) {
+    L.writeLowHigh(ContinueStmtBits.ContinueLoc_lo, ContinueLoc_hi);
+  }
 
   SourceLocation getBeginLoc() const { return getContinueLoc(); }
   SourceLocation getEndLoc() const { return getContinueLoc(); }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ContinueStmtClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
 
   const_child_range children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 };
 
 /// BreakStmt - This represents a break.
 class BreakStmt : public Stmt {
+  SourceLocation::OptionalHighBits BreakLoc_hi;
+
 public:
   BreakStmt(SourceLocation BL) : Stmt(BreakStmtClass) {
     setBreakLoc(BL);
   }
 
   /// Build an empty break statement.
   explicit BreakStmt(EmptyShell Empty) : Stmt(BreakStmtClass, Empty) {}
 
-  SourceLocation getBreakLoc() const { return BreakStmtBits.BreakLoc; }
-  void setBreakLoc(SourceLocation L) { BreakStmtBits.BreakLoc = L; }
+  SourceLocation getBreakLoc() const {
+    return SourceLocation::getFromLowHigh(BreakStmtBits.BreakLoc_lo,
+                                          BreakLoc_hi);
+  }
+  void setBreakLoc(SourceLocation L) {
+    L.writeLowHigh(BreakStmtBits.BreakLoc_lo, BreakLoc_hi);
+  }
 
   SourceLocation getBeginLoc() const { return getBreakLoc(); }
   SourceLocation getEndLoc() const { return getBreakLoc(); }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == BreakStmtClass;
   }
 

 /// return a value, and it allows returning a value in functions declared to
 /// return void.  We explicitly model this in the AST, which means you can't
 /// depend on the return type of the function and the presence of an argument.
 class ReturnStmt final
     : public Stmt,
       private llvm::TrailingObjects<ReturnStmt, const VarDecl *> {
   friend TrailingObjects;
 
+  /// The location of the "return".
+  SourceLocation::OptionalHighBits RetLoc_hi;
+
   /// The return expression.
   Stmt *RetExpr;
 
   // ReturnStmt is followed optionally by a trailing "const VarDecl *"
   // for the NRVO candidate. Present if and only if hasNRVOCandidate().
 
   /// True if this ReturnStmt has storage for an NRVO candidate.
   bool hasNRVOCandidate() const { return ReturnStmtBits.HasNRVOCandidate; }
public:
   /// optimization. The return statement must have storage for it,
   /// which is the case if and only if hasNRVOCandidate() is true.
   void setNRVOCandidate(const VarDecl *Var) {
     assert(hasNRVOCandidate() &&
            "This return statement has no storage for an NRVO candidate!");
     *getTrailingObjects<const VarDecl *>() = Var;
   }
 
-  SourceLocation getReturnLoc() const { return ReturnStmtBits.RetLoc; }
-  void setReturnLoc(SourceLocation L) { ReturnStmtBits.RetLoc = L; }
+  SourceLocation getReturnLoc() const {
+    return SourceLocation::getFromLowHigh(ReturnStmtBits.RetLoc_lo, RetLoc_hi);
+  }
+  void setReturnLoc(SourceLocation L) {
+    L.writeLowHigh(ReturnStmtBits.RetLoc_lo, RetLoc_hi);
+  }
 
   SourceLocation getBeginLoc() const { return getReturnLoc(); }
   SourceLocation getEndLoc() const LLVM_READONLY {
     return RetExpr ? RetExpr->getEndLoc() : getReturnLoc();
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ReturnStmtClass;

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;
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:
+  class LowBits {
+    friend class SourceLocation;
+    uint32_t lo;
+  };
+#ifdef CLANG_64_BIT_SOURCE_LOCATIONS
+  using UIntType = uint64_t;
+  using IntType = int64_t;
+  class OptionalHighBits {
+    friend class SourceLocation;
+    uint32_t hi;
+  };
+  static SourceLocation getFromLowHigh(LowBits L, OptionalHighBits H) {
+    return getFromRawEncoding(((uint64_t)H.hi << 32) | L.lo);
+  }
+  void writeLowHigh(LowBits &L, OptionalHighBits &H) {
+    L.lo = ID;
+    H.hi = ID >> 32;
+  }
+  bool getRawEncoding32(uint32_t &Result) const {
+    if ((ID ^ (ID << 1)) & 0x7FFFFFFF80000000)
+      return false; // won't fit
+    uint32_t TruncatedValue = ID & 0x7FFFFFFF;
+    Result = TruncatedValue | ((ID & 0x8000000000000000) >> 32);
+    return true;
+  }
+  static SourceLocation getFromRawEncoding32(uint32_t Raw32) {
+    uint64_t Raw = Raw32 & 0x7FFFFFFF;
+    Raw += 0x1FFFFFFFE * (Raw & 0x40000000);
+    Raw |= (uint64_t)(Raw32 & 0x80000000) << 32;
+    return getFromRawEncoding(Raw);
+  }
+#else
+  using UIntType = uint32_t;
+  using IntType = int32_t;
+  class OptionalHighBits {};
+  static SourceLocation getFromLowHigh(LowBits L, OptionalHighBits H) {
+    return getFromRawEncoding(L.lo);
+  }
+  void writeLowHigh(LowBits &L, OptionalHighBits &H) { L.lo = ID; }
+  bool getRawEncoding32(uint32_t &Result) const {
+    Result = ID;
+    return true;
+  }
+  static SourceLocation getFromRawEncoding32(uint32_t Raw32) {
+    return getFromRawEncoding(Raw32);
+  }
+#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

 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

private:
   /// the PCH chain must be eagerly deserialized.
   SmallVector<serialization::DeclID, 16> TentativeDefinitions;
 
   /// The IDs of all CXXRecordDecls stored in the chain whose VTables are
   /// used.
   ///
   /// CodeGen has to emit VTables for these records, so they have to be eagerly
   /// deserialized.
-  SmallVector<serialization::DeclID, 64> VTableUses;
+  SmallVector<uint64_t, 64> VTableUses;
 
   /// A snapshot of the pending instantiations in the chain.
   ///
   /// This record tracks the instantiations that Sema has to perform at the
   /// end of the TU. It consists of a pair of values for every pending
   /// instantiation where the first value is the ID of the decl and the second
   /// is the instantiation location.
-  SmallVector<serialization::DeclID, 64> PendingInstantiations;
+  SmallVector<uint64_t, 64> PendingInstantiations;
 
   //@}
 
   /// \name DiagnosticsEngine-relevant special data
   /// Fields containing data that is used for generating diagnostics
   //@{
 
   /// A snapshot of Sema's unused file-scoped variable tracking, for
   /// generating warnings.
   SmallVector<serialization::DeclID, 16> UnusedFileScopedDecls;
 
   /// A list of all the delegating constructors we've seen, to diagnose
   /// cycles.
   SmallVector<serialization::DeclID, 4> DelegatingCtorDecls;
 
   /// Method selectors used in a @selector expression. Used for
   /// implementation of -Wselector.
-  SmallVector<serialization::SelectorID, 64> ReferencedSelectorsData;
+  SmallVector<uint64_t, 64> ReferencedSelectorsData;
 
   /// A snapshot of Sema's weak undeclared identifier tracking, for
   /// generating warnings.
-  SmallVector<serialization::IdentifierID, 64> WeakUndeclaredIdentifiers;
+  SmallVector<uint64_t, 64> WeakUndeclaredIdentifiers;
 
   /// The IDs of type aliases for ext_vectors that exist in the chain.
   ///
   /// Used by Sema for finding sugared names for ext_vectors in diagnostics.
   SmallVector<serialization::DeclID, 4> ExtVectorDecls;
 
   //@}
 
private:
   /// Extensions required by an OpenCL declaration.
   llvm::DenseMap<const Decl *, std::set<std::string>> OpenCLDeclExtMap;
 
   /// A list of the namespaces we've seen.
   SmallVector<serialization::DeclID, 4> KnownNamespaces;
 
   /// A list of undefined decls with internal linkage followed by the
   /// SourceLocation of a matching ODR-use.
-  SmallVector<serialization::DeclID, 8> UndefinedButUsed;
+  SmallVector<uint64_t, 8> UndefinedButUsed;
 
   /// Delete expressions to analyze at the end of translation unit.
   SmallVector<uint64_t, 8> DelayedDeleteExprs;
 
   // A list of late parsed template function data with their module files.
   SmallVector<std::pair<ModuleFile *, SmallVector<uint64_t, 1>>, 4>
       LateParsedTemplates;
 
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/Expr.cpp

DeclRefExpr::DeclRefExpr(const ASTContext &Ctx, ValueDecl *D,
     : Expr(DeclRefExprClass, T, VK, OK_Ordinary), D(D), DNLoc(LocInfo) {
   DeclRefExprBits.HasQualifier = false;
   DeclRefExprBits.HasTemplateKWAndArgsInfo = false;
   DeclRefExprBits.HasFoundDecl = false;
   DeclRefExprBits.HadMultipleCandidates = false;
   DeclRefExprBits.RefersToEnclosingVariableOrCapture =
       RefersToEnclosingVariableOrCapture;
   DeclRefExprBits.NonOdrUseReason = NOUR;
-  DeclRefExprBits.Loc = L;
+  setLocation(L);
   setDependence(computeDependence(this, Ctx));
 }
 
 DeclRefExpr::DeclRefExpr(const ASTContext &Ctx,
                          NestedNameSpecifierLoc QualifierLoc,
                          SourceLocation TemplateKWLoc, ValueDecl *D,
                          bool RefersToEnclosingVariableOrCapture,
                          const DeclarationNameInfo &NameInfo, NamedDecl *FoundD,
                          const TemplateArgumentListInfo *TemplateArgs,
                          QualType T, ExprValueKind VK, NonOdrUseReason NOUR)
     : Expr(DeclRefExprClass, T, VK, OK_Ordinary), D(D),
       DNLoc(NameInfo.getInfo()) {
-  DeclRefExprBits.Loc = NameInfo.getLoc();
+  setLocation(NameInfo.getLoc());
   DeclRefExprBits.HasQualifier = QualifierLoc ? 1 : 0;
   if (QualifierLoc)
     new (getTrailingObjects<NestedNameSpecifierLoc>())
         NestedNameSpecifierLoc(QualifierLoc);
   DeclRefExprBits.HasFoundDecl = FoundD ? 1 : 0;
   if (FoundD)
     *getTrailingObjects<NamedDecl *>() = FoundD;
   DeclRefExprBits.HasTemplateKWAndArgsInfo

 PredefinedExpr::PredefinedExpr(SourceLocation L, QualType FNTy, IdentKind IK,
                                StringLiteral *SL)
     : Expr(PredefinedExprClass, FNTy, VK_LValue, OK_Ordinary) {
   PredefinedExprBits.Kind = IK;
   assert((getIdentKind() == IK) &&
          "IdentKind do not fit in PredefinedExprBitfields!");
   bool HasFunctionName = SL != nullptr;
   PredefinedExprBits.HasFunctionName = HasFunctionName;
-  PredefinedExprBits.Loc = L;
+  setLocation(L);
   if (HasFunctionName)
     setFunctionName(SL);
   setDependence(computeDependence(this));
 }
 
 PredefinedExpr::PredefinedExpr(EmptyShell Empty, bool HasFunctionName)
     : Expr(PredefinedExprClass, Empty) {
   PredefinedExprBits.HasFunctionName = HasFunctionName;
: Expr(MemberExprClass, T, VK, OK), Base(Base), MemberDecl(MemberDecl),
       MemberDNLoc(NameInfo.getInfo()), MemberLoc(NameInfo.getLoc()) {
   assert(!NameInfo.getName() ||
          MemberDecl->getDeclName() == NameInfo.getName());
   MemberExprBits.IsArrow = IsArrow;
   MemberExprBits.HasQualifierOrFoundDecl = false;
   MemberExprBits.HasTemplateKWAndArgsInfo = false;
   MemberExprBits.HadMultipleCandidates = false;
   MemberExprBits.NonOdrUseReason = NOUR;
-  MemberExprBits.OperatorLoc = OperatorLoc;
+  setOperatorLoc(OperatorLoc);
   setDependence(computeDependence(this));
 }
 
 MemberExpr *MemberExpr::Create(
     const ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc,
     NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
     ValueDecl *MemberDecl, DeclAccessPair FoundDecl,
     DeclarationNameInfo NameInfo, const TemplateArgumentListInfo *TemplateArgs,
: Expr(GenericSelectionExprClass, AssocExprs[ResultIndex]->getType(),
            AssocExprs[ResultIndex]->getObjectKind()),
       NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),
       DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
   assert(AssocTypes.size() == AssocExprs.size() &&
          "Must have the same number of association expressions"
          " and TypeSourceInfo!");
   assert(ResultIndex < NumAssocs && "ResultIndex is out-of-bounds!");
 
-  GenericSelectionExprBits.GenericLoc = GenericLoc;
+  setGenericLoc(GenericLoc);
   getTrailingObjects<Stmt *>()[ControllingIndex] = ControllingExpr;
   std::copy(AssocExprs.begin(), AssocExprs.end(),
             getTrailingObjects<Stmt *>() + AssocExprStartIndex);
   std::copy(AssocTypes.begin(), AssocTypes.end(),
             getTrailingObjects<TypeSourceInfo *>());
 
   setDependence(computeDependence(this, ContainsUnexpandedParameterPack));
 }
 
 GenericSelectionExpr::GenericSelectionExpr(
     const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr,
     ArrayRef<TypeSourceInfo *> AssocTypes, ArrayRef<Expr *> AssocExprs,
     SourceLocation DefaultLoc, SourceLocation RParenLoc,
     bool ContainsUnexpandedParameterPack)
     : Expr(GenericSelectionExprClass, Context.DependentTy, VK_RValue,
            OK_Ordinary),
       NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),
       DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
   assert(AssocTypes.size() == AssocExprs.size() &&
          "Must have the same number of association expressions"
          " and TypeSourceInfo!");
 
-  GenericSelectionExprBits.GenericLoc = GenericLoc;
+  setGenericLoc(GenericLoc);
   getTrailingObjects<Stmt *>()[ControllingIndex] = ControllingExpr;
   std::copy(AssocExprs.begin(), AssocExprs.end(),
             getTrailingObjects<Stmt *>() + AssocExprStartIndex);
   std::copy(AssocTypes.begin(), AssocTypes.end(),
             getTrailingObjects<TypeSourceInfo *>());
 
   setDependence(computeDependence(this, ContainsUnexpandedParameterPack));
 }

 BinaryOperator::BinaryOperator(const ASTContext &Ctx, Expr *lhs, Expr *rhs,
                                Opcode opc, QualType ResTy, ExprValueKind VK,
                                ExprObjectKind OK, SourceLocation opLoc,
                                FPOptionsOverride FPFeatures)
     : Expr(BinaryOperatorClass, ResTy, VK, OK) {
   BinaryOperatorBits.Opc = opc;
   assert(!isCompoundAssignmentOp() &&
          "Use CompoundAssignOperator for compound assignments");
-  BinaryOperatorBits.OpLoc = opLoc;
+  setOperatorLoc(opLoc);
   SubExprs[LHS] = lhs;
   SubExprs[RHS] = rhs;
   BinaryOperatorBits.HasFPFeatures = FPFeatures.requiresTrailingStorage();
   if (hasStoredFPFeatures())
     setStoredFPFeatures(FPFeatures);
   setDependence(computeDependence(this));
 }
 
 BinaryOperator::BinaryOperator(const ASTContext &Ctx, Expr *lhs, Expr *rhs,
                                Opcode opc, QualType ResTy, ExprValueKind VK,
                                ExprObjectKind OK, SourceLocation opLoc,
                                FPOptionsOverride FPFeatures, bool dead2)
     : Expr(CompoundAssignOperatorClass, ResTy, VK, OK) {
   BinaryOperatorBits.Opc = opc;
   assert(isCompoundAssignmentOp() &&
          "Use CompoundAssignOperator for compound assignments");
-  BinaryOperatorBits.OpLoc = opLoc;
+  setOperatorLoc(opLoc);
   SubExprs[LHS] = lhs;
   SubExprs[RHS] = rhs;
   BinaryOperatorBits.HasFPFeatures = FPFeatures.requiresTrailingStorage();
   if (hasStoredFPFeatures())
     setStoredFPFeatures(FPFeatures);
   setDependence(computeDependence(this));
 }
 

 
 UnaryOperator::UnaryOperator(const ASTContext &Ctx, Expr *input, Opcode opc,
                              QualType type, ExprValueKind VK, ExprObjectKind OK,
                              SourceLocation l, bool CanOverflow,
                              FPOptionsOverride FPFeatures)
     : Expr(UnaryOperatorClass, type, VK, OK), Val(input) {
   UnaryOperatorBits.Opc = opc;
   UnaryOperatorBits.CanOverflow = CanOverflow;
-  UnaryOperatorBits.Loc = l;
+  setOperatorLoc(l);
   UnaryOperatorBits.HasFPFeatures = FPFeatures.requiresTrailingStorage();
   if (hasStoredFPFeatures())
     setStoredFPFeatures(FPFeatures);
   setDependence(computeDependence(this, Ctx));
 }
 
 UnaryOperator *UnaryOperator::Create(const ASTContext &C, Expr *input,
                                      Opcode opc, QualType type,

clang/lib/AST/ExprCXX.cpp

CXXDefaultInitExpr::CXXDefaultInitExpr(const ASTContext &Ctx,
                                        SourceLocation Loc, FieldDecl *Field,
                                        QualType Ty, DeclContext *UsedContext)
     : Expr(CXXDefaultInitExprClass, Ty.getNonLValueExprType(Ctx),
            Ty->isLValueReferenceType()
                ? VK_LValue
                : Ty->isRValueReferenceType() ? VK_XValue : VK_RValue,
            /*FIXME*/ OK_Ordinary),
       Field(Field), UsedContext(UsedContext) {
-  CXXDefaultInitExprBits.Loc = Loc;
+  setUsedLocation(Loc);
   assert(Field->hasInClassInitializer());
 
   setDependence(computeDependence(this));
 }
 
 CXXTemporary *CXXTemporary::Create(const ASTContext &C,
                                    const CXXDestructorDecl *Destructor) {
   return new (C) CXXTemporary(Destructor);
CXXConstructExpr::CXXConstructExpr(
     : Expr(SC, Ty, VK_RValue, OK_Ordinary), Constructor(Ctor),
       ParenOrBraceRange(ParenOrBraceRange), NumArgs(Args.size()) {
   CXXConstructExprBits.Elidable = Elidable;
   CXXConstructExprBits.HadMultipleCandidates = HadMultipleCandidates;
   CXXConstructExprBits.ListInitialization = ListInitialization;
   CXXConstructExprBits.StdInitListInitialization = StdInitListInitialization;
   CXXConstructExprBits.ZeroInitialization = ZeroInitialization;
   CXXConstructExprBits.ConstructionKind = ConstructKind;
-  CXXConstructExprBits.Loc = Loc;
+  setLocation(Loc);
 
   Stmt **TrailingArgs = getTrailingArgs();
   for (unsigned I = 0, N = Args.size(); I != N; ++I) {
     assert(Args[I] && "NULL argument in CXXConstructExpr!");
     TrailingArgs[I] = Args[I];
   }
 
   setDependence(computeDependence(this));
: Expr(CXXDependentScopeMemberExprClass, Ctx.DependentTy, VK_LValue,
            OK_Ordinary),
       Base(Base), BaseType(BaseType), QualifierLoc(QualifierLoc),
       MemberNameInfo(MemberNameInfo) {
   CXXDependentScopeMemberExprBits.IsArrow = IsArrow;
   CXXDependentScopeMemberExprBits.HasTemplateKWAndArgsInfo =
       (TemplateArgs != nullptr) || TemplateKWLoc.isValid();
   CXXDependentScopeMemberExprBits.HasFirstQualifierFoundInScope =
       FirstQualifierFoundInScope != nullptr;
-  CXXDependentScopeMemberExprBits.OperatorLoc = OperatorLoc;
+  setOperatorLoc(OperatorLoc);
 
   if (TemplateArgs) {
     auto Deps = TemplateArgumentDependence::None;
     getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
         TemplateKWLoc, *TemplateArgs, getTrailingObjects<TemplateArgumentLoc>(),
         Deps);
   } else if (TemplateKWLoc.isValid()) {
     getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(

clang/lib/AST/ExprConcepts.cpp

RequiresExpr::RequiresExpr(ASTContext &C, SourceLocation RequiresKWLoc,
                            RequiresExprBodyDecl *Body,
                            ArrayRef<ParmVarDecl *> LocalParameters,
                            ArrayRef<concepts::Requirement *> Requirements,
                            SourceLocation RBraceLoc)
     : Expr(RequiresExprClass, C.BoolTy, VK_RValue, OK_Ordinary),
       NumLocalParameters(LocalParameters.size()),
       NumRequirements(Requirements.size()), Body(Body), RBraceLoc(RBraceLoc) {
   RequiresExprBits.IsSatisfied = false;
-  RequiresExprBits.RequiresKWLoc = RequiresKWLoc;
+  setRequiresKWLoc(RequiresKWLoc);
   bool Dependent = false;
   bool ContainsUnexpandedParameterPack = false;
   for (ParmVarDecl *P : LocalParameters) {
     Dependent |= P->getType()->isInstantiationDependentType();
     ContainsUnexpandedParameterPack |=
         P->getType()->containsUnexpandedParameterPack();
   }
   RequiresExprBits.IsSatisfied = true;

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/AST/Stmt.cpp

int64_t Stmt::getID(const ASTContext &Context) const {
   return Context.getAllocator().identifyKnownAlignedObject<Stmt>(this);
 }
 
 CompoundStmt::CompoundStmt(ArrayRef<Stmt *> Stmts, SourceLocation LB,
                            SourceLocation RB)
     : Stmt(CompoundStmtClass), RBraceLoc(RB) {
   CompoundStmtBits.NumStmts = Stmts.size();
   setStmts(Stmts);
-  CompoundStmtBits.LBraceLoc = LB;
+  setLBracLoc(LB);
 }
 
 void CompoundStmt::setStmts(ArrayRef<Stmt *> Stmts) {
   assert(CompoundStmtBits.NumStmts == Stmts.size() &&
          "NumStmts doesn't fit in bits of CompoundStmtBits.NumStmts!");
 
   std::copy(Stmts.begin(), Stmts.end(), body_begin());
 }
ForStmt::ForStmt(const ASTContext &C, Stmt *Init, Expr *Cond, VarDecl *condVar,
                  SourceLocation RP)
   : Stmt(ForStmtClass), LParenLoc(LP), RParenLoc(RP)
 {
   SubExprs[INIT] = Init;
   setConditionVariable(C, condVar);
   SubExprs[COND] = Cond;
   SubExprs[INC] = Inc;
   SubExprs[BODY] = Body;
-  ForStmtBits.ForLoc = FL;
+  setForLoc(FL);
 }
 
 VarDecl *ForStmt::getConditionVariable() const {
   if (!SubExprs[CONDVAR])
     return nullptr;
 
   auto *DS = cast<DeclStmt>(SubExprs[CONDVAR]);
   return cast<VarDecl>(DS->getSingleDecl());

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 HasUnwindClobber, bool ReadOnly,
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/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);
+    uint64_t SLocOffset = endian::readNext<uint64_t, 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();
+    // SourceLocations are serialized as uint64_t, irrespective of
+    // CLANG_64_BIT_SOURCE_LOCATIONS. So we have to bounds-check them
+    // when reading back in.
+    if (SLocOffset > std::numeric_limits<SourceLocation::UIntType>::max()) {
+      Error("This version of clang cannot handle SourceLocations bigger than "
+            "32 bits");
+      return;
+    }
 
     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/ASTReaderStmt.cpp

 
 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
   VisitStmt(S);
   SmallVector<Stmt *, 16> Stmts;
   unsigned NumStmts = Record.readInt();
   while (NumStmts--)
     Stmts.push_back(Record.readSubStmt());
   S->setStmts(Stmts);
-  S->CompoundStmtBits.LBraceLoc = readSourceLocation();
+  S->setLBracLoc(readSourceLocation());
   S->RBraceLoc = readSourceLocation();
 }
 
 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
   VisitStmt(S);
   Record.recordSwitchCaseID(S, Record.readInt());
   S->setKeywordLoc(readSourceLocation());
   S->setColonLoc(readSourceLocation());
void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
   uint64_t NumAttrs = Record.readInt();
   AttrVec Attrs;
   Record.readAttributes(Attrs);
   (void)NumAttrs;
   assert(NumAttrs == S->AttributedStmtBits.NumAttrs);
   assert(NumAttrs == Attrs.size());
   std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr());
   S->SubStmt = Record.readSubStmt();
-  S->AttributedStmtBits.AttrLoc = readSourceLocation();
+  S->setAttrLoc(readSourceLocation());
 }
 
 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
   VisitStmt(S);
 
   S->setConstexpr(Record.readInt());
   bool HasElse = Record.readInt();
   bool HasVar = Record.readInt();
return new (Record.getContext())
       concepts::Requirement::SubstitutionDiagnostic{SubstitutedEntity, DiagLoc,
                                                     DiagMessage};
 }
 
 void ASTStmtReader::VisitRequiresExpr(RequiresExpr *E) {
   VisitExpr(E);
   unsigned NumLocalParameters = Record.readInt();
   unsigned NumRequirements = Record.readInt();
-  E->RequiresExprBits.RequiresKWLoc = Record.readSourceLocation();
+  E->setRequiresKWLoc(Record.readSourceLocation());
   E->RequiresExprBits.IsSatisfied = Record.readInt();
   E->Body = Record.readDeclAs<RequiresExprBodyDecl>();
   llvm::SmallVector<ParmVarDecl *, 4> LocalParameters;
   for (unsigned i = 0; i < NumLocalParameters; ++i)
     LocalParameters.push_back(cast<ParmVarDecl>(Record.readDecl()));
   std::copy(LocalParameters.begin(), LocalParameters.end(),
             E->getTrailingObjects<ParmVarDecl *>());
   llvm::SmallVector<concepts::Requirement *, 4> Requirements;
void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
   E->MemberDecl = Record.readDeclAs<ValueDecl>();
   E->MemberDNLoc = Record.readDeclarationNameLoc(E->MemberDecl->getDeclName());
   E->MemberLoc = Record.readSourceLocation();
   E->MemberExprBits.IsArrow = Record.readInt();
   E->MemberExprBits.HasQualifierOrFoundDecl = HasQualifier || HasFoundDecl;
   E->MemberExprBits.HasTemplateKWAndArgsInfo = HasTemplateInfo;
   E->MemberExprBits.HadMultipleCandidates = Record.readInt();
   E->MemberExprBits.NonOdrUseReason = Record.readInt();
-  E->MemberExprBits.OperatorLoc = Record.readSourceLocation();
+  E->setOperatorLoc(Record.readSourceLocation());
 
   if (HasQualifier || HasFoundDecl) {
     DeclAccessPair FoundDecl;
     if (HasFoundDecl) {
       auto *FoundD = Record.readDeclAs<NamedDecl>();
       auto AS = (AccessSpecifier)Record.readInt();
       FoundDecl = DeclAccessPair::make(FoundD, AS);
     } else {

 }
 
 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
   VisitExpr(E);
 
   unsigned NumAssocs = Record.readInt();
   assert(NumAssocs == E->getNumAssocs() && "Wrong NumAssocs!");
   E->ResultIndex = Record.readInt();
-  E->GenericSelectionExprBits.GenericLoc = readSourceLocation();
+  E->setGenericLoc(readSourceLocation());
   E->DefaultLoc = readSourceLocation();
   E->RParenLoc = readSourceLocation();
 
   Stmt **Stmts = E->getTrailingObjects<Stmt *>();
   // Add 1 to account for the controlling expression which is the first
   // expression in the trailing array of Stmt *. This is not needed for
   // the trailing array of TypeSourceInfo *.
   for (unsigned I = 0, N = NumAssocs + 1; I < N; ++I)
void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
   assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
 
   E->CXXConstructExprBits.Elidable = Record.readInt();
   E->CXXConstructExprBits.HadMultipleCandidates = Record.readInt();
   E->CXXConstructExprBits.ListInitialization = Record.readInt();
   E->CXXConstructExprBits.StdInitListInitialization = Record.readInt();
   E->CXXConstructExprBits.ZeroInitialization = Record.readInt();
   E->CXXConstructExprBits.ConstructionKind = Record.readInt();
-  E->CXXConstructExprBits.Loc = readSourceLocation();
+  E->setLocation(readSourceLocation());
   E->Constructor = readDeclAs<CXXConstructorDecl>();
   E->ParenOrBraceRange = readSourceRange();
 
   for (unsigned I = 0; I != NumArgs; ++I)
     E->setArg(I, Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {

 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
   VisitExpr(E);
   E->setLocation(readSourceLocation());
   E->setImplicit(Record.readInt());
 }
 
 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
   VisitExpr(E);
-  E->CXXThrowExprBits.ThrowLoc = readSourceLocation();
+  E->setThrowLoc(readSourceLocation());
   E->Operand = Record.readSubExpr();
   E->CXXThrowExprBits.IsThrownVariableInScope = Record.readInt();
 }
 
 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
   VisitExpr(E);
   E->Param = readDeclAs<ParmVarDecl>();
   E->UsedContext = readDeclAs<DeclContext>();
-  E->CXXDefaultArgExprBits.Loc = readSourceLocation();
+  E->setUsedLocation(readSourceLocation());
 }
 
 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
   VisitExpr(E);
   E->Field = readDeclAs<FieldDecl>();
   E->UsedContext = readDeclAs<DeclContext>();
-  E->CXXDefaultInitExprBits.Loc = readSourceLocation();
+  E->setUsedLocation(readSourceLocation());
 }
 
 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
   VisitExpr(E);
   E->setTemporary(Record.readCXXTemporary());
   E->setSubExpr(Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
   VisitExpr(E);
   E->TypeInfo = readTypeSourceInfo();
-  E->CXXScalarValueInitExprBits.RParenLoc = readSourceLocation();
+  E->setRParenLoc(readSourceLocation());
 }
 
 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
   VisitExpr(E);
 
   bool IsArray = Record.readInt();
   bool HasInit = Record.readInt();
   unsigned NumPlacementArgs = Record.readInt();

 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
   VisitExpr(E);
   E->CXXDeleteExprBits.GlobalDelete = Record.readInt();
   E->CXXDeleteExprBits.ArrayForm = Record.readInt();
   E->CXXDeleteExprBits.ArrayFormAsWritten = Record.readInt();
   E->CXXDeleteExprBits.UsualArrayDeleteWantsSize = Record.readInt();
   E->OperatorDelete = readDeclAs<FunctionDecl>();
   E->Argument = Record.readSubExpr();
-  E->CXXDeleteExprBits.Loc = readSourceLocation();
+  E->setLocation(readSourceLocation());
 }
 
 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
   VisitExpr(E);
 
   E->Base = Record.readSubExpr();
   E->IsArrow = Record.readInt();
   E->OperatorLoc = readSourceLocation();
if (HasTemplateKWAndArgsInfo)
     ReadTemplateKWAndArgsInfo(
         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
         E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
 
   assert((NumTemplateArgs == E->getNumTemplateArgs()) &&
          "Wrong NumTemplateArgs!");
 
   E->CXXDependentScopeMemberExprBits.IsArrow = Record.readInt();
-  E->CXXDependentScopeMemberExprBits.OperatorLoc = readSourceLocation();
+  E->setOperatorLoc(readSourceLocation());
   E->BaseType = Record.readType();
   E->QualifierLoc = Record.readNestedNameSpecifierLoc();
   E->Base = Record.readSubExpr();
 
   if (HasFirstQualifierFoundInScope)
     *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>();
 
   E->MemberNameInfo = Record.readDeclarationNameInfo();
void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
   }
 }
 
 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
                                               SubstNonTypeTemplateParmExpr *E) {
   VisitExpr(E);
   E->ParamAndRef.setPointer(readDeclAs<NonTypeTemplateParmDecl>());
   E->ParamAndRef.setInt(Record.readInt());
-  E->SubstNonTypeTemplateParmExprBits.NameLoc = readSourceLocation();
+  E->setNameLoc(readSourceLocation());
   E->Replacement = Record.readSubExpr();
 }
 
 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
                                           SubstNonTypeTemplateParmPackExpr *E) {
   VisitExpr(E);
   E->Param = readDeclAs<NonTypeTemplateParmDecl>();
   TemplateArgument ArgPack = Record.readTemplateArgument();
void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
   E->SubExprs[1] = Record.readSubExpr();
   E->SubExprs[2] = Record.readSubExpr();
   E->Opcode = (BinaryOperatorKind)Record.readInt();
 }
 
 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
   VisitExpr(E);
   E->SourceExpr = Record.readSubExpr();
-  E->OpaqueValueExprBits.Loc = readSourceLocation();
+  E->setLocation(readSourceLocation());
   E->setIsUnique(Record.readInt());
 }
 
 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
   llvm_unreachable("Cannot read TypoExpr nodes");
 }
 
 void ASTStmtReader::VisitRecoveryExpr(RecoveryExpr *E) {

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);
+
+        // SourceLocations are serialized as uint64_t, irrespective of
+        // CLANG_64_BIT_SOURCE_LOCATIONS
+        writeBaseIDOrNone(static_cast<uint64_t>(M.SLocEntryBaseOffset),
+                          M.LocalNumSLocEntries);
         writeBaseIDOrNone(M.BaseIdentifierID, M.LocalNumIdentifiers);
         writeBaseIDOrNone(M.BaseMacroID, M.LocalNumMacros);
         writeBaseIDOrNone(M.BasePreprocessedEntityID,
                           M.NumPreprocessedEntities);
         writeBaseIDOrNone(M.BaseSubmoduleID, M.LocalNumSubmodules);
         writeBaseIDOrNone(M.BaseSelectorID, M.LocalNumSelectors);
         writeBaseIDOrNone(M.BaseDeclID, M.LocalNumDecls);
         writeBaseIDOrNone(M.BaseTypeIndex, M.LocalNumTypes);

 
 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/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitConceptSpecializationExpr(
 
   Code = serialization::EXPR_CONCEPT_SPECIALIZATION;
 }
 
 void ASTStmtWriter::VisitRequiresExpr(RequiresExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getLocalParameters().size());
   Record.push_back(E->getRequirements().size());
-  Record.AddSourceLocation(E->RequiresExprBits.RequiresKWLoc);
+  Record.AddSourceLocation(E->getRequiresKWLoc());
   Record.push_back(E->RequiresExprBits.IsSatisfied);
   Record.AddDeclRef(E->getBody());
   for (ParmVarDecl *P : E->getLocalParameters())
     Record.AddDeclRef(P);
   for (concepts::Requirement *R : E->getRequirements()) {
     if (auto *TypeReq = dyn_cast<concepts::TypeRequirement>(R)) {
       Record.push_back(concepts::Requirement::RK_Type);
       Record.push_back(TypeReq->Status);

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

if (EndLoc.isValid() && EndLoc.isMacroID() &&
     IsTokenRange = Expansion.isTokenRange();
   }
   if (IsTokenRange && EndLoc.isValid()) {
     unsigned Length =
         Lexer::MeasureTokenLength(SM.getSpellingLoc(EndLoc), SM, LangOpts);
     EndLoc = EndLoc.getLocWithOffset(Length);
   }
 
-  CXSourceRange Result = {
-      {&SM, &LangOpts}, R.getBegin().getRawEncoding(), EndLoc.getRawEncoding()};
+  uint32_t BeginRaw, EndRaw;
+  if (!R.getBegin().getRawEncoding32(BeginRaw) ||
+      !EndLoc.getRawEncoding32(EndRaw))
+    return clang_getNullRange(); // location is too big for libclang ABI
+  CXSourceRange Result = {{&SM, &LangOpts},
+                          static_cast<unsigned>(BeginRaw),
+                          static_cast<unsigned>(EndRaw)};
   return Result;
 }
 
 CharSourceRange cxloc::translateCXRangeToCharRange(CXSourceRange R) {
   return CharSourceRange::getCharRange(
-      SourceLocation::getFromRawEncoding(R.begin_int_data),
-      SourceLocation::getFromRawEncoding(R.end_int_data));
+      SourceLocation::getFromRawEncoding32(R.begin_int_data),
+      SourceLocation::getFromRawEncoding32(R.end_int_data));
 }
 
 //===----------------------------------------------------------------------===//
 // Cursor visitor.
 //===----------------------------------------------------------------------===//
 
 static SourceRange getRawCursorExtent(CXCursor C);
 static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr);
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::getFromRawEncoding32(
+        (SourceLocation::UIntType)(uintptr_t)data[1]);
   }
 };
 class EnqueueVisitor : public ConstStmtVisitor<EnqueueVisitor, void> {
   friend class OMPClauseEnqueue;
   VisitorWorkList &WL;
   CXCursor Parent;
 
 public:
CXString clang_getTokenSpelling(CXTranslationUnit TU, CXToken CXTok) {
   }
 
   // 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::getFromRawEncoding32(CXTok.int_data[1]);
   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]));
 }
 
 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::getFromRawEncoding32(CXTok.int_data[1]));
 }
 
 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::getFromRawEncoding32(CXTok.int_data[1]));
 }
 
-static void getTokens(ASTUnit *CXXUnit, SourceRange Range,
+static bool 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 =
       SourceMgr.getDecomposedSpellingLoc(Range.getEnd());
 
   // Cannot tokenize across files.
   if (BeginLocInfo.first != EndLocInfo.first)
-    return;
+    return false;
 
   // Create a lexer
   bool Invalid = false;
   StringRef Buffer = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid);
   if (Invalid)
-    return;
+    return false;
 
   Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first),
             CXXUnit->getASTContext().getLangOpts(), Buffer.begin(),
             Buffer.data() + BeginLocInfo.second, Buffer.end());
   Lex.SetCommentRetentionState(true);
 
   // Lex tokens until we hit the end of the range.
   const char *EffectiveBufferEnd = Buffer.data() + EndLocInfo.second;
   Token Tok;
   bool previousWasAt = false;
   do {
     // Lex the next token
     Lex.LexFromRawLexer(Tok);
     if (Tok.is(tok::eof))
       break;
 
     // Initialize the CXToken.
     CXToken CXTok;
 
     //   - Common fields
-    CXTok.int_data[1] = Tok.getLocation().getRawEncoding();
+    uint32_t TokLocRaw;
+    if (!Tok.getLocation().getRawEncoding32(TokLocRaw))
+      return false; // location is too big for libclang ABI
+    CXTok.int_data[1] = TokLocRaw;
     CXTok.int_data[2] = Tok.getLength();
     CXTok.int_data[3] = 0;
 
     //   - Kind-specific fields
     if (Tok.isLiteral()) {
       CXTok.int_data[0] = CXToken_Literal;
       CXTok.ptr_data = const_cast<char *>(Tok.getLiteralData());
     } else if (Tok.is(tok::raw_identifier)) {
if (Tok.isLiteral()) {
       CXTok.ptr_data = nullptr;
     } else {
       CXTok.int_data[0] = CXToken_Punctuation;
       CXTok.ptr_data = nullptr;
     }
     CXTokens.push_back(CXTok);
     previousWasAt = Tok.is(tok::at);
   } while (Lex.getBufferLocation() < EffectiveBufferEnd);
+
+  return true;
 }
 
 CXToken *clang_getToken(CXTranslationUnit TU, CXSourceLocation Location) {
   LOG_FUNC_SECTION { *Log << TU << ' ' << Location; }
 
   if (isNotUsableTU(TU)) {
     LOG_BAD_TU(TU);
     return NULL;
CXToken *clang_getToken(CXTranslationUnit TU, CXSourceLocation Location) {
   std::pair<FileID, unsigned> DecomposedEnd = SM.getDecomposedLoc(Begin);
   DecomposedEnd.second +=
       Lexer::MeasureTokenLength(Begin, SM, CXXUnit->getLangOpts());
 
   SourceLocation End =
       SM.getComposedLoc(DecomposedEnd.first, DecomposedEnd.second);
 
   SmallVector<CXToken, 32> CXTokens;
-  getTokens(CXXUnit, SourceRange(Begin, End), CXTokens);
+  if (!getTokens(CXXUnit, SourceRange(Begin, End), CXTokens))
+    return NULL;
 
   if (CXTokens.empty())
     return NULL;
 
   CXTokens.resize(1);
   CXToken *Token = static_cast<CXToken *>(llvm::safe_malloc(sizeof(CXToken)));
 
   memmove(Token, CXTokens.data(), sizeof(CXToken));
void clang_tokenize(CXTranslationUnit TU, CXSourceRange Range, CXToken **Tokens,
 
   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
 
   SourceRange R = cxloc::translateCXSourceRange(Range);
   if (R.isInvalid())
     return;
 
   SmallVector<CXToken, 32> CXTokens;
-  getTokens(CXXUnit, R, CXTokens);
+  if (!getTokens(CXXUnit, R, CXTokens))
+    return;
 
   if (CXTokens.empty())
     return;
 
   *Tokens = static_cast<CXToken *>(
       llvm::safe_malloc(sizeof(CXToken) * CXTokens.size()));
   memmove(*Tokens, CXTokens.data(), sizeof(CXToken) * CXTokens.size());
   *NumTokens = CXTokens.size();
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::getFromRawEncoding32(getTok(tokI).int_data[1]);
   }
   bool isFunctionMacroToken(unsigned tokI) const {
     return getTok(tokI).int_data[3] != 0;
   }
   SourceLocation getFunctionMacroTokenLoc(unsigned tokI) const {
-    return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[3]);
+    return SourceLocation::getFromRawEncoding32(getTok(tokI).int_data[3]);
   }
 
   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::getFromRawEncoding32(getTok(tokI).int_data[1]);
   }
 
   void setFunctionMacroTokenLoc(unsigned tokI, SourceLocation loc) {
     // The third 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();
+    uint32_t Raw;
+    if (!loc.getRawEncoding32(Raw))
+      Raw = 0; // invalid source location
+    getTok(tokI).int_data[3] = Raw;
   }
 };
 
 } // 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::getFromRawEncoding32(Tokens[TokIdx].int_data[1]));
 
   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::getFromRawEncoding32(Tokens[LastIdx].int_data[1]);
       CXCursor Cursor =
           MakePreprocessingDirectiveCursor(SourceRange(BeginLoc, EndLoc), TU);
 
       for (; TokIdx <= LastIdx; ++TokIdx)
         updateCursorAnnotation(Cursors[TokIdx], Cursor);
 
       if (finished)
         break;

clang/tools/libclang/CXIndexDataConsumer.cpp

if (RD->isThisDeclarationADefinition()) {
     CXXDInfo.CXXClassInfo.numBases = BaseList.getNumBases();
 
     if (shouldSuppressRefs()) {
       // Go through bases and mark them as referenced.
       for (unsigned i = 0, e = BaseList.getNumBases(); i != e; ++i) {
         const CXIdxBaseClassInfo *baseInfo = BaseList.getBases()[i];
         if (baseInfo->base) {
           const NamedDecl *BaseD = BaseList.BaseEntities[i].Dcl;
-          SourceLocation
-            Loc = SourceLocation::getFromRawEncoding(baseInfo->loc.int_data);
+          SourceLocation Loc =
+              SourceLocation::getFromRawEncoding32(baseInfo->loc.int_data);
           markEntityOccurrenceInFile(BaseD, Loc);
         }
       }
     }
 
     return handleDecl(OrigD, OrigD->getLocation(), getCursor(OrigD), CXXDInfo);
   }
 
CXIdxClientFile CXIndexDataConsumer::getIndexFile(const FileEntry *File) {
   return nullptr;
 }
 
 CXIdxLoc CXIndexDataConsumer::getIndexLoc(SourceLocation Loc) const {
   CXIdxLoc idxLoc =  { {nullptr, nullptr}, 0 };
   if (Loc.isInvalid())
     return idxLoc;
 
+  uint32_t LocRaw;
+  if (!Loc.getRawEncoding32(LocRaw))
+    return idxLoc;
+
   idxLoc.ptr_data[0] = const_cast<CXIndexDataConsumer *>(this);
-  idxLoc.int_data = Loc.getRawEncoding();
+  idxLoc.int_data = LocRaw;
   return idxLoc;
 }
 
 void CXIndexDataConsumer::translateLoc(SourceLocation Loc,
                                    CXIdxClientFile *indexFile, CXFile *file,
                                    unsigned *line, unsigned *column,
                                    unsigned *offset) {
   if (Loc.isInvalid())

clang/tools/libclang/CXSourceLocation.h

 
 /// Translate a Clang source location into a CIndex source location.
 static inline CXSourceLocation 
 translateSourceLocation(const SourceManager &SM, const LangOptions &LangOpts,
                         SourceLocation Loc) {
   if (Loc.isInvalid())
     return clang_getNullLocation();
 
-  CXSourceLocation Result = { { &SM, &LangOpts, },
-                              Loc.getRawEncoding() };
+  uint32_t LocRaw;
+  if (!Loc.getRawEncoding32(LocRaw))
+    return clang_getNullLocation(); // location is too big for libclang ABI
+
+  CXSourceLocation Result = {{&SM, &LangOpts}, static_cast<unsigned>(LocRaw)};
   return Result;
 }
-  
 /// Translate a Clang source location into a CIndex source location.
 static inline CXSourceLocation translateSourceLocation(ASTContext &Context,
                                                        SourceLocation Loc) {
   return translateSourceLocation(Context.getSourceManager(),
                                  Context.getLangOpts(),
                                  Loc);
 }
 

 static inline CXSourceRange translateSourceRange(ASTContext &Context,
                                                  SourceRange R) {
   return translateSourceRange(Context.getSourceManager(),
                               Context.getLangOpts(),
                               CharSourceRange::getTokenRange(R));
 }
 
 static inline SourceLocation translateSourceLocation(CXSourceLocation L) {
-  return SourceLocation::getFromRawEncoding(L.int_data);
+  return SourceLocation::getFromRawEncoding32(L.int_data);
 }
 
 static inline SourceRange translateCXSourceRange(CXSourceRange R) {
-  return SourceRange(SourceLocation::getFromRawEncoding(R.begin_int_data),
-                     SourceLocation::getFromRawEncoding(R.end_int_data));
+  return SourceRange(SourceLocation::getFromRawEncoding32(R.begin_int_data),
+                     SourceLocation::getFromRawEncoding32(R.end_int_data));
 }
 
 /// Translates CXSourceRange to CharSourceRange.
 /// The semantics of \p R are:
 /// R.begin_int_data is first character of the range.
 /// R.end_int_data is one character past the end of the range.
 CharSourceRange translateCXRangeToCharRange(CXSourceRange R);
 }} // end namespace: clang::cxloc
 
 #endif

clang/tools/libclang/CXSourceLocation.cpp

static void createNullLocation(CXString *filename, unsigned *line,
   if (column)
     *column = 0;
   if (offset)
     *offset = 0;
 }
 
 int clang_Location_isInSystemHeader(CXSourceLocation location) {
   const SourceLocation Loc =
-    SourceLocation::getFromRawEncoding(location.int_data);
+      SourceLocation::getFromRawEncoding32(location.int_data);
   if (Loc.isInvalid())
     return 0;
 
   const SourceManager &SM =
     *static_cast<const SourceManager*>(location.ptr_data[0]);
   return SM.isInSystemHeader(Loc);
 }
 
 int clang_Location_isFromMainFile(CXSourceLocation location) {
   const SourceLocation Loc =
-    SourceLocation::getFromRawEncoding(location.int_data);
+      SourceLocation::getFromRawEncoding32(location.int_data);
   if (Loc.isInvalid())
     return 0;
 
   const SourceManager &SM =
     *static_cast<const SourceManager*>(location.ptr_data[0]);
   return SM.isWrittenInMainFile(Loc);
 }
 
 void clang_getExpansionLocation(CXSourceLocation location,
                                 CXFile *file,
                                 unsigned *line,
                                 unsigned *column,
                                 unsigned *offset) {
   if (!isASTUnitSourceLocation(location)) {
     CXLoadedDiagnostic::decodeLocation(location, file, line, column, offset);
     return;
   }
 
-  SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data);
+  SourceLocation Loc = SourceLocation::getFromRawEncoding32(location.int_data);
 
   if (!location.ptr_data[0] || Loc.isInvalid()) {
     createNullLocation(file, line, column, offset);
     return;
   }
 
   const SourceManager &SM =
   *static_cast<const SourceManager*>(location.ptr_data[0]);
void clang_getPresumedLocation(CXSourceLocation location,
                                unsigned *column) {
   if (!isASTUnitSourceLocation(location)) {
     // Other SourceLocation implementations do not support presumed locations
     // at this time.
     createNullLocation(filename, line, column);
     return;
   }
 
-  SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data);
+  SourceLocation Loc = SourceLocation::getFromRawEncoding32(location.int_data);
 
   if (!location.ptr_data[0] || Loc.isInvalid()) {
     createNullLocation(filename, line, column);
     return;
   }
 
   const SourceManager &SM =
       *static_cast<const SourceManager *>(location.ptr_data[0]);
void clang_getSpellingLocation(CXSourceLocation location,
                                unsigned *line,
                                unsigned *column,
                                unsigned *offset) {
   if (!isASTUnitSourceLocation(location)) {
     CXLoadedDiagnostic::decodeLocation(location, file, line,
                                            column, offset);
     return;
   }
-  
-  SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data);
-  
+  SourceLocation Loc = SourceLocation::getFromRawEncoding32(location.int_data);
   if (!location.ptr_data[0] || Loc.isInvalid())
     return createNullLocation(file, line, column, offset);
   
   const SourceManager &SM =
   *static_cast<const SourceManager*>(location.ptr_data[0]);
   // FIXME: This should call SourceManager::getSpellingLoc().
   SourceLocation SpellLoc = SM.getFileLoc(Loc);
   std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(SpellLoc);
void clang_getFileLocation(CXSourceLocation location,
                            unsigned *column,
                            unsigned *offset) {
   if (!isASTUnitSourceLocation(location)) {
     CXLoadedDiagnostic::decodeLocation(location, file, line,
                                            column, offset);
     return;
   }
 
-  SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data);
+  SourceLocation Loc = SourceLocation::getFromRawEncoding32(location.int_data);
 
   if (!location.ptr_data[0] || Loc.isInvalid())
     return createNullLocation(file, line, column, offset);
 
   const SourceManager &SM =
   *static_cast<const SourceManager*>(location.ptr_data[0]);
   SourceLocation FileLoc = SM.getFileLoc(Loc);
   std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(FileLoc);

clang/tools/libclang/Indexing.cpp

void clang_indexLoc_getFileLocation(CXIdxLoc location,
                                     unsigned *column,
                                     unsigned *offset) {
   if (indexFile) *indexFile = nullptr;
   if (file)   *file = nullptr;
   if (line)   *line = 0;
   if (column) *column = 0;
   if (offset) *offset = 0;
 
-  SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data);
+  SourceLocation Loc = SourceLocation::getFromRawEncoding32(location.int_data);
   if (!location.ptr_data[0] || Loc.isInvalid())
     return;
 
   CXIndexDataConsumer &DataConsumer =
       *static_cast<CXIndexDataConsumer*>(location.ptr_data[0]);
   DataConsumer.translateLoc(Loc, indexFile, file, line, column, offset);
 }
 
 CXSourceLocation clang_indexLoc_getCXSourceLocation(CXIdxLoc location) {
-  SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data);
+  SourceLocation Loc = SourceLocation::getFromRawEncoding32(location.int_data);
   if (!location.ptr_data[0] || Loc.isInvalid())
     return clang_getNullLocation();
 
   CXIndexDataConsumer &DataConsumer =
       *static_cast<CXIndexDataConsumer*>(location.ptr_data[0]);
   return cxloc::translateSourceLocation(DataConsumer.getASTContext(), Loc);
 }

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
   /// 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,
   // Don't implicitly switch to the text section before the asm.
   (void)Parser->Run(/*NoInitialTextSection*/ true,
                     /*NoFinalize*/ true);
   emitInlineAsmEnd(STI, &TAP->getSTI());
 }
 
 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, const MCAsmInfo *MAI,
-                                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();
   int AsmPrinterVariant = MAI->getAssemblerDialect();
 
   if (MAI->getEmitGNUAsmStartIndentationMarker())
     OS << '\t';
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

void setParsingMSInlineAsm(bool V) override {
     Lexer.setLexMasmIntegers(V);
   }
   bool isParsingMSInlineAsm() override { return ParsingMSInlineAsm; }
 
   bool discardLTOSymbol(StringRef Name) const override {
     return LTODiscardSymbols.contains(Name);
   }
 
-  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;