ext_address_space attribute

[agozillon]

Summary

The addition of a new attribute ext_address_space that supplements the existing address_space attribute by allowing dependent integers to be used in conjunction with address spaces. It takes a lot of inspiration from the existing ext_vector_type attribute which similarly allows the acceptance of dependent integer values. This addition allows address spaces to be used in conjunction with templates like the following basic function:

template <unsigned Nv>
int get_as(int attribute((ext_address_space(Nv))) *) {

return Nv;

}

This modification requires the addition of a new attribute ext_address_space and a new type DependentExtAddressSpaceType, alongside the relevant boiler plate code required for these new additions. Such as case statements for template deduction and name mangling. The ext_ part of the attribute name is following the naming convention of ext_vector_type, as it currently extends the existing address_space attributes functionality. The DependentExtAddressSpaceType is a new type for storing the dependent address space integer passed to it and the type it's to be attached to. DependentExtAddressSpaceType is based on ext_vector_type's DependentSizedExtVectorType, so future modifications to this type could also be considered for DependentExtAddressSpaceType. One large example is the addition of a more specific type location class.

There is one difference between the ext_vector_type and ext_address_space attributes and it's that ext_address_space can be used outside of using and typedef declarations.

The handling of the ext_address_space attribute inside SemaType.cpp is similar to the address_space attribute and aims to emit the same diagnostic errors and functionality that it does. In fact it would be possible to integrate the both of them. However, I did not wish to during my implementation of this functionality in-case it had adverse effects.

[rjmccall]

ext_vector_type is a different attribute from vector_type because the argument has different semantics (it's the element count instead of the vector size) and the resulting vector type has different type-checking behavior (e.g. with member expressions). These do not seem to be true of ext_address_space. You should use the same attribute spelling and just allow the argument expression to be value-dependent.

I'm uncertain about this representation. Address-space qualifiers are still fundamentally qualifiers, but this turns dependent address spaces into something very different from a non-dependent address space. We could make Qualifiers / ExtQuals capable of storing dependent address-space expressions. That would at least ensure that getUnqualifiedType() automatically did the right thing with them.

include/clang/AST/Type.h

1713

It is better style to just wrap the comment here. The comment is also needlessly redundant; I would just say "value-dependent address space qualifier".

include/clang/Serialization/ASTBitCodes.h

937

Reformatting this block doesn't seem completely unreasonable, because the indentation is not completely consistent, but if you want to do it, please do it as a separate commit.

[Anastasia]

Btw, in OpenCL C++ similar issue is solved using storage classes (similar to smart pointers), see https://www.khronos.org/registry/OpenCL/specs/opencl-2.2-cplusplus.pdf#40 s2.5 for more details. Wondering if this approach could help here too although I could imagine the issue might be with the fact that any arbitrary number is used for AS in C/C++ instead of a known set as in OpenCL.

[agozillon]

Modifications based on the Type.h and ASTBitcodes.h comments made by @rjmccall namely modifying the isDependentExtAddressSpaceType() comment and reverting the formatting performed on the ASTBitcodes.h TypeCode enumerator.

[rjmccall]

I would still like more people's input on whether a Type node is the right way to represent this vs. something on ExtQuals. I guess I am leaning towards saying that it should be on ExtQuals unless we think there's something deeply problematic about having a dependent type qualifier.

include/clang/AST/ASTContext.h

1283

Why is this called PointerType? An address space qualifier goes on the pointee type.

That question applies to a lot of this patch.

include/clang/AST/TypeLoc.h

1696

If we leave this as a Type node, would you mind just doing this? Most of the other FIXMEs here date from when we added TypeLoc originally; it would be nice to avoid accumulating new ones.

include/clang/Sema/ExternalSemaSource.h

146 ↗

(On Diff #101511)

You don't actually seem to have done anything with this idea; you're just accumulating them.

It might be reasonable to teach the type printer to be more reluctant about looking through address space typedefs, like how it's reluctant to look through vector typedefs. But you'd have to be careful, because the typedef can also accumulate sugar on the underlying type.

lib/AST/ASTContext.cpp

3133

The code that works with qualifiers often strips qualifiers and then re-applies them. I feel it's important to deviate from the model of DependentlySizedExtVectorType here and make an effort to produce the same Type object when the expression and type match exactly.

3144

Please hoist this to where you called getCanonicalType earlier.

lib/AST/ItaniumMangle.cpp

2976

Did you just make up this mangling? You should at least make an issue for it on the C++ ABI:

https://github.com/itanium-cxx-abi/cxx-abi

lib/Sema/SemaTemplateDeduction.cpp

1829

Shouldn't this be ">="? And I think you don't need the 0 +.

lib/Sema/SemaType.cpp

5390

The outer check is stronger than the inner check. I think you should just be doing getAs<DependentExtAddressSpaceType>().

5592

This definitely need to be a getAs<>. It's not okay to stack up these qualifiers no matter how you've done it.

Or you could split the type and see if the Qualifiers contains a dependent address space qualifier.

[rjmccall]

Okay, well, nobody else is cooperating and sending feedback on the design, and it's not dissimilar from the design we already use for AtomicType, so I guess we can commit to it unless Richard wants to weigh in.

[agozillon]

In D33666#768808, @Anastasia wrote:

Btw, in OpenCL C++ similar issue is solved using storage classes (similar to smart pointers), see https://www.khronos.org/registry/OpenCL/specs/opencl-2.2-cplusplus.pdf#40 s2.5 for more details. Wondering if this approach could help here too although I could imagine the issue might be with the fact that any arbitrary number is used for AS in C/C++ instead of a known set as in OpenCL.

lib/AST/ASTContext.cpp

3133

In this case if you mean just returning the result of the FindNodeOrInsertPos call if it finds an existing node, I'm unsure it will work. I did test to make sure however.

The main issue in that case is that the SourceLocation is tied to the type, which is needed to print out diagnostic errors if something goes wrong during instantiation. Returning the Node will in most cases return a type with the incorrect SourceLocation which can lead to some oddly placed error messages.

[agozillon]

Tried to address all of the points made in the last review, a few should be ticked off the list. However, a couple will most definitely need revisited as I need a little more direction on them I shall leave these points unchecked for now (mostly the mangling and the one revision I have replied to already). It is possible that some of the revisions I check off will be considered incorrect, so it's fine to reopen them with a little more input!

The largest change was the addition of a new TypeLoc class in relation to the DependentExtAddressSpaceType. Most of the others were trivial modifications, other than the Mangling which is still a work in progress.

[agozillon]

lib/AST/ItaniumMangle.cpp

2976

A little more direction on what to do with the qualifiers in this Mangling would be appreciated. I was under the incorrect assumption that passing the expression and type to there own mangling variation would handle the qualifiers.

[rjmccall]

lib/AST/ItaniumMangle.cpp

2976

Since your type is really just a qualifier, and it's not naturally ordered with other qualifiers (i.e. 'attribute((address_space(N))) const' is the same thing as 'const attribute((address_space(N)))'), you have to actually think about how other qualifiers will be canonically represented vis-a-vis your node. That is, will you always put other qualifiers "outside" your node or "inside" it? This is a much bigger issue than just mangling and really affects basically everything in the compiler that deals with qualifiers.

• However you decide that, the ABI then has a requirement about the order in which unordered qualifiers are mangled, with the goal of ensuring that they are always mangled in the same order instead of randomly jumbled about based on how the type was written.

These reasons are part of why I was arguing that you might want to store the expression on ExtQuals instead of making it a Type node — the idea being that a type can have some sort of address-space qualifier, and that qualifier might be dependent (an Expr*) or not (an unsigned). The main difficulty with doing that, I think, is that you'll be introducing the concept of a dependent type qualifier, which means that things like Type::isDependentType() will need to be pulled up to QualType and you'll have to go touch a lot of code. But I think on balance that might save you a lot of grief, and I'm sure we'll eventually find other uses for dependent qualifiers.

[agozillon]

I have made modifications to the DependentExtAddressSpaceType mangleType function to follow the ABI specification. I am unsure if it's entirely correct yet (as such I would greatly appreciate some verification), but I believe it's moving in the right direction.

At the moment I believe the output from the mangling for a type of: const volatile int attribute((ext_address_space(N))) *, where the N is a dependent variable that is constant would be - PU2ASIKT_EVKi (however, please do correct me if my understanding is incorrect).

[rjmccall]

lib/AST/ItaniumMangle.cpp

2982

Mangling the qualifiers on the address-space expression's type is not correct. Just mangle the expression.

[agozillon]

Removal of the Address Space Expr qualifier mangling that was not required, the mangling should now be correct I believe.

I think I have addressed all of the currently marked review points.

[agozillon]

I have marked the mangling review point as "Done" as I believe it is now addressed, however if it still needs further modification I am of course happy to re-open the review point and make amends.

[rjmccall]

include/clang/AST/Type.h

2802

I thought we had agreed that this should be just be the normal address_space attribute, but with a dependent expression.

lib/AST/ItaniumMangle.cpp

2980

I think the only reasonable way to get qualifier-ordering correctness here is going to be to make mangleQualifiers take an optional DepenentAddressSpaceType* and, if it's present, mangle it in the appropriate position.

You should call split() on T->getPointeeType() and make sure that the recursive call here mangles the unqualified type.

lib/Sema/SemaType.cpp

5542

Type-dependence implies value-dependence.

[rjmccall]

lib/Sema/SemaType.cpp

5542

Oh, but you actually need to build a DependentAddressSpaceType if the expression is instantiation-dependent, not just value-dependent. IIRC, the test case would be something like:

address_space(true ? 0 : some_expression_that_might_not_instantiate)

[agozillon]

include/clang/AST/Type.h

2802

By this do you mean remove the ext_address_space notation and just merge the functionality with the current address_space attribute? If so I shall do this, I was a little unsure on what we had decided previously so I apologies for not modifying it sooner.

[rjmccall]

include/clang/AST/Type.h

2802

Yes, that's what I mean. There's no semantic difference, it's a pure generalization of the current attribute.

[agozillon]

Merged old ext_address_space functionality into address_space. So now address_space can work with template parameters.

I made modifications to the mangling again, I am a little unsure where in the mangleQualifiers the dependent mangling should go however (so it will most likely need further tweaking). e.g. before or after the non-dependent AS mangling.

I also modified the if statement to check for value dependency and instantiation dependency, rather than value and type dependency.

[rjmccall]

include/clang/AST/RecursiveASTVisitor.h

994

Is there actually a valid case where this expression is null?

include/clang/AST/Type.h

2749

The second sentence in this comment isn't quite how I'd put it. How about:

Non-dependent address spaces are not represented with a special Type subclass; they
are stored on an ExtQuals node as part of a QualType.

2766

Indentation.

include/clang/AST/TypeLoc.h

1682

Might as well have the ~~~~ cover the entire attribute name, just to avoid confusion.

1692

Indentation so that this lines up with the 11 again.

1703

Indentation.

include/clang/Sema/Sema.h

1373

Indentation.

lib/AST/ASTContext.cpp

2311

Capitalization, ending period.

2317

I'd just drop this comment.

2320

Capitalization.

3126

Please include an assertion that the expression is instantiation-dependent.

3133

You'd just be hashing by Expr* identity here, so it's likely that the source locations would be the same.

It would not be correct to try to hash by Expr structural equality.

lib/AST/ItaniumMangle.cpp

2203

This is the right place to put this in this function. It can't be combined with a non-dependent address space, and it comes alphabetically after all the others (because they start with underscores).

The more important thing is that you need to make sure that all the places which call mangleQualifiers also try to destructure a DependentAddressSpaceType at the same time. This might mean that the normal path for mangling a DependentAddressSpaceType never gets called.

lib/Sema/SemaDecl.cpp

14350

T->isDependentAddressSpaceType()

14352

T->getBaseElementTypeUnsafe()->isDependentAddressSpaceType()

lib/Sema/SemaType.cpp

5410

This doesn't seem right. The nested TypeLoc in a DependentAddressSpaceType should be for the underlying type; you shouldn't be separately allocating anything.

5503

Why did you remove the "Type Attribute Processing" section header?

5507

Value dependence implies instantiation dependence.

5642

Please remove dead code instead of just commenting it out.

[agozillon]

With these patch modifications I believe I corrected all of the incorrect indentation and commenting notified from the last set of review points. I also brought back the Type Attribute Processing header which I accidentally removed (sorry!). I also marked off all of the smaller review points that I modified to reflect the modifications made.

The first of the larger modifications I made is that I modified the TypeLoc code (@5410~) in SemaType.cpp to perform more like AtomicTypeLoc and AttributedTypeLoc, which I believe is the correct way to deal with DependentAddressSpaceTypeLoc in this scenario (correct me if I am wrong however).

I also added destructuring of DependentAddressSpaceType's in relevant places where mangleQualifiers gets invoked inside ItaniumMangle.cpp. The two locations where I don't destructure a DependentAddressSpaceType before mangleQualifiers is invoked are in the FunctionProtoType overload and the mangleNestedName's function. In both cases because they're dealing with types that are not DependentAddressSpaceType's and they're also only looking for CVR qualifiers (no address space qualifiers or vendor extensions). I believe this is correct, but as always feel free to correct me.

I also modified getDependentAddressSpaceType inside ASTContext.cpp to try and return the same Type when the Type and Expr are the same, however I think it still needs some work. I am unsure in this case what's meant by hashing by Expr* rather than Expr structural equality. In this case would it mean ID.AddPointer(AddrSpaceExpr) instead of AddrSpaceExpr->Profile(ID, Context, true) inside the DependentAddressSpaceType profile function? The former hashing by a pointer and the latter hashing by strucutre?

Thank you for your time.

include/clang/AST/RecursiveASTVisitor.h

994

I don't believe there is, any time a DependentAddressSpaceType is instantiated their should be an Expr to go with it.

lib/Sema/SemaType.cpp

5642

Sorry, I forgot to remove this before modifying the patch! Thank you for pointing it out.

[rjmccall]

In D33666#873056, @agozillon wrote:

The first of the larger modifications I made is that I modified the TypeLoc code (@5410~) in SemaType.cpp to perform more like AtomicTypeLoc and AttributedTypeLoc, which I believe is the correct way to deal with DependentAddressSpaceTypeLoc in this scenario (correct me if I am wrong however).

That looks right, thanks.

I also added destructuring of DependentAddressSpaceType's in relevant places where mangleQualifiers gets invoked inside ItaniumMangle.cpp. The two locations where I don't destructure a DependentAddressSpaceType before mangleQualifiers is invoked are in the FunctionProtoType overload and the mangleNestedName's function. In both cases because they're dealing with types that are not DependentAddressSpaceType's and they're also only looking for CVR qualifiers (no address space qualifiers or vendor extensions). I believe this is correct, but as always feel free to correct me.

Yes, those are more restricted cases where this qualifier is not possible.

I also modified getDependentAddressSpaceType inside ASTContext.cpp to try and return the same Type when the Type and Expr are the same, however I think it still needs some work. I am unsure in this case what's meant by hashing by Expr* rather than Expr structural equality. In this case would it mean ID.AddPointer(AddrSpaceExpr) instead of AddrSpaceExpr->Profile(ID, Context, true) inside the DependentAddressSpaceType profile function? The former hashing by a pointer and the latter hashing by strucutre?

Yes, exactly. Essentially we're saying that types written in different places in the source code are always different types.

...but when I really stop to think about it, that doesn't actually seem like the right rule. That's the rule we use for VariableArrayType, because that C99 says that different VLA types are always different, which makes sense since the expression may actually be different in different contexts. But it's probably not the right rule for this, because the expression isn't really dynamic like a VLA bound, it's just dependent. Comparing expressions by equivalence rather than source equality is the rule used in order to test whether e.g. a function template is a redeclaration of another. It's the rule used by DependentSizedArrayType, and it's almost certainly the right rule to use here, too. I suggest following the basic model used by getDependentSizedArrayType and its corresponding Profile methods.

Thank you for your time.

[agozillon]

The main modifications with this change is to make the getDependentAddressSpaceType function similarly to getDependentSizedArrayType. Alongside modifying the DependentAddressSpaceType profile to hash by Expr structure similarly to DependentSizedArrayType.

The getDependentAddressSpaceType function couldn't be made to function exactly the same, mainly as getDependentSizedArrayType moves the qualifiers from its internal type (elementType) onto itself. Which doesn't work in the case of DependentAddressSpaceType, I believe. There was also a case for a scenario where the sizeExpr was null, however the AddrSpaceExpr should never be null as far as I'm aware so the case would never be invoked. That's the two main modifications that separate the two types get functions. However, if the function is still incorrect I am as always happy to make further changes.

I think this is the last modification asked for at the moment.

Thanks again.

[rjmccall]

Looks great. A few test requests.

test/Sema/address_space-dependent.cpp

1 ↗

(On Diff #115600)

This file belongs in test/SemaTemplate/.

Please add a test to verify that two identical template function declarations expressed using the same dependent address space are treated as redeclarations of each other. I think this should work:

template <unsigned A> int __attribute__((address_space(A))) *same_template();
template <unsigned B> int __attribute__((address_space(B))) *same_template();
void test_same_template() { (void) same_template<0>(); }

template <unsigned A> int __attribute__((address_space(A))) *different_template();
template <unsigned B> int __attribute__((address_space(B+1))) *different_template();
void test_same_template() { (void) different_template<0>(); } // should give an ambiguity error

Please also add tests that class template partial specializations can successfully deduce an address space, e.g.:

template <class T> struct partial_spec;
template <class T, unsigned AS> struct partial_spec<__attribute__((address_space(AS))) T *> {};
partial_spec<__attribute__((address_space(0))) int *> test_partial_spec = {};

[agozillon]

Adding the new mentioned tests and moving the test file to the correct specified folder.

[agozillon]

Setting older review points to done and setting the newer Test review point to done as I have now added the new tests and moved it to the appropriate folder.

[rjmccall]

LGTM, thanks!

[agozillon]

In D33666#880288, @rjmccall wrote:

LGTM, thanks!

Sorry to bother you again. As I am quite new to the Clang/LLVM review process I was wondering what the next steps after a revisions acceptance are and if I have any further part to play? I did have a read through some of the documentation on reviews but I unfortunately couldn't find any further information.

[rjmccall]

In D33666#880607, @agozillon wrote:

In D33666#880288, @rjmccall wrote:

LGTM, thanks!

Sorry to bother you again. As I am quite new to the Clang/LLVM review process I was wondering what the next steps after a revisions acceptance are and if I have any further part to play? I did have a read through some of the documentation on reviews but I unfortunately couldn't find any further information.

Once the patch is accepted, and you've tested it locally to your satisfaction, you can go ahead and commit. It's then your responsibility to pay attention to any build-bot failures — which you should get email notification of — for a day or so to check that they don't seem related to your patch.

Do you have commit access?

[agozillon]

In D33666#880668, @rjmccall wrote:

In D33666#880607, @agozillon wrote:

In D33666#880288, @rjmccall wrote:

LGTM, thanks!

Sorry to bother you again. As I am quite new to the Clang/LLVM review process I was wondering what the next steps after a revisions acceptance are and if I have any further part to play? I did have a read through some of the documentation on reviews but I unfortunately couldn't find any further information.

Once the patch is accepted, and you've tested it locally to your satisfaction, you can go ahead and commit. It's then your responsibility to pay attention to any build-bot failures — which you should get email notification of — for a day or so to check that they don't seem related to your patch.

Do you have commit access?

I unfortunately do not have commit access at the moment, I wasn't sure if I would be able to get commit access as a first time contributor. Would applying for commit access be possible at this point?

[rjmccall]

In D33666#880788, @agozillon wrote:

In D33666#880668, @rjmccall wrote:

In D33666#880607, @agozillon wrote:

In D33666#880288, @rjmccall wrote:

LGTM, thanks!

Sorry to bother you again. As I am quite new to the Clang/LLVM review process I was wondering what the next steps after a revisions acceptance are and if I have any further part to play? I did have a read through some of the documentation on reviews but I unfortunately couldn't find any further information.

Once the patch is accepted, and you've tested it locally to your satisfaction, you can go ahead and commit. It's then your responsibility to pay attention to any build-bot failures — which you should get email notification of — for a day or so to check that they don't seem related to your patch.

Do you have commit access?

I unfortunately do not have commit access at the moment, I wasn't sure if I would be able to get commit access as a first time contributor. Would applying for commit access be possible at this point?

If you intend to stick around and keep contributing patches, go ahead and ask for commit access.

John.

[agozillon]

In D33666#883931, @rjmccall wrote:

In D33666#880788, @agozillon wrote:

In D33666#880668, @rjmccall wrote:

In D33666#880607, @agozillon wrote:

In D33666#880288, @rjmccall wrote:

LGTM, thanks!

Sorry to bother you again. As I am quite new to the Clang/LLVM review process I was wondering what the next steps after a revisions acceptance are and if I have any further part to play? I did have a read through some of the documentation on reviews but I unfortunately couldn't find any further information.

Once the patch is accepted, and you've tested it locally to your satisfaction, you can go ahead and commit. It's then your responsibility to pay attention to any build-bot failures — which you should get email notification of — for a day or so to check that they don't seem related to your patch.

Do you have commit access?

I unfortunately do not have commit access at the moment, I wasn't sure if I would be able to get commit access as a first time contributor. Would applying for commit access be possible at this point?

If you intend to stick around and keep contributing patches, go ahead and ask for commit access.

John.

I have now gained commit access and committed the modifications from this review: https://github.com/llvm-mirror/clang/commit/d27ee8f21eebc00294112a46121537238cdda59f

Thank you very much for your time, help and patience over the course of this review John.

include/clang/AST/ASTContext.h

   mutable llvm::FoldingSet<DependentSizedArrayType> DependentSizedArrayTypes;
   mutable llvm::FoldingSet<DependentSizedExtVectorType>
     DependentSizedExtVectorTypes;
+  mutable llvm::FoldingSet<DependentAddressSpaceType>
+      DependentAddressSpaceTypes;
   mutable llvm::FoldingSet<VectorType> VectorTypes;
   mutable llvm::FoldingSet<FunctionNoProtoType> FunctionNoProtoTypes;
   mutable llvm::ContextualFoldingSet<FunctionProtoType, ASTContext&>

   /// replaced.
   QualType getAddrSpaceQualType(QualType T, unsigned AddressSpace) const;
 
+  /// \brief Remove any existing address space on the type and returns the type
+  /// with qualifiers intact (or that's the idea anyway)
+  ///
+  /// The return type should be T with all prior qualifiers minus the address
+  /// space.
+  QualType removeAddrSpaceQualType(QualType T) const;
+
   /// \brief Apply Objective-C protocol qualifiers to the given type.
   /// \param allowOnPointerType specifies if we can apply protocol
   /// qualifiers on ObjCObjectPointerType. It can be set to true when

                                           Expr *SizeExpr,
                                           SourceLocation AttrLoc) const;
 
+  QualType getDependentAddressSpaceType(QualType PointeeType,
+                                        Expr *AddrSpaceExpr,
+                                        SourceLocation AttrLoc) const;
+
   /// \brief Return a K&R style C function type like 'int()'.
   QualType getFunctionNoProtoType(QualType ResultTy,
                                   const FunctionType::ExtInfo &Info) const;

include/clang/AST/RecursiveASTVisitor.h

     TRY_TO(TraverseStmt(T->getSizeExpr()));
 })
 
+DEF_TRAVERSE_TYPE(DependentAddressSpaceType, {
+  TRY_TO(TraverseStmt(T->getAddrSpaceExpr()));
+  TRY_TO(TraverseType(T->getPointeeType()));
+})
+
 DEF_TRAVERSE_TYPE(DependentSizedExtVectorType, {
   if (T->getSizeExpr())
     TRY_TO(TraverseStmt(T->getSizeExpr()));

   return TraverseArrayTypeLocHelper(TL);
 })
 
+DEF_TRAVERSE_TYPELOC(DependentAddressSpaceType, {
+  TRY_TO(TraverseStmt(TL.getTypePtr()->getAddrSpaceExpr()));
+  TRY_TO(TraverseType(TL.getTypePtr()->getPointeeType()));
+})
+
 // FIXME: order? why not size expr first?
 // FIXME: base VectorTypeLoc is unfinished
 DEF_TRAVERSE_TYPELOC(DependentSizedExtVectorType, {

include/clang/AST/Type.h

   bool isComplexIntegerType() const;            // GCC _Complex integer type.
   bool isVectorType() const;                    // GCC vector type.
   bool isExtVectorType() const;                 // Extended vector type.
+  bool isDependentAddressSpaceType() const;     // value-dependent address space qualifier
   bool isObjCObjectPointerType() const;         // pointer to ObjC object
   bool isObjCRetainableType() const;            // ObjC object or block pointer
   bool isObjCLifetimeType() const;              // (array of)* retainable type

                       unsigned TypeQuals, Expr *E);
 };
 
+/// Represents an extended address space qualifier where the input address space
+/// value is dependent. Non-dependent address spaces are not represented with a 
+/// special Type subclass; they are stored on an ExtQuals node as part of a QualType.
+///
+/// For example:
+/// \code
+/// template<typename T, int AddrSpace>
+/// class AddressSpace {
+///   typedef T __attribute__((address_space(AddrSpace))) type;
+/// }
+/// \endcode
+class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode {
+  const ASTContext &Context;
+  Expr *AddrSpaceExpr;
+  QualType PointeeType;
+  SourceLocation loc;
+
+  DependentAddressSpaceType(const ASTContext &Context, QualType PointeeType,
+                            QualType can, Expr *AddrSpaceExpr, 
+                            SourceLocation loc);
+
+  friend class ASTContext;
+
+public:
+  Expr *getAddrSpaceExpr() const { return AddrSpaceExpr; }
+  QualType getPointeeType() const { return PointeeType; }
+  SourceLocation getAttributeLoc() const { return loc; }
+
+  bool isSugared() const { return false; }
+  QualType desugar() const { return QualType(this, 0); }
+
+  static bool classof(const Type *T) {
+    return T->getTypeClass() == DependentAddressSpace;
+  }
+
+  void Profile(llvm::FoldingSetNodeID &ID) {
+    Profile(ID, Context, getPointeeType(), getAddrSpaceExpr());
+  }
+
+  static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
+                      QualType PointeeType, Expr *AddrSpaceExpr);
+};
+
 /// Represents an extended vector type where either the type or size is
 /// dependent.
 ///

 inline bool Type::isExtVectorType() const {
   return isa<ExtVectorType>(CanonicalType);
 }
+inline bool Type::isDependentAddressSpaceType() const {
+  return isa<DependentAddressSpaceType>(CanonicalType);
+}
 inline bool Type::isObjCObjectPointerType() const {
   return isa<ObjCObjectPointerType>(CanonicalType);
 }

include/clang/AST/TypeLoc.h

   }
 };
 
+struct DependentAddressSpaceLocInfo {
+  Expr *ExprOperand;
+  SourceRange OperandParens;
+  SourceLocation AttrLoc;
+};
+
+class DependentAddressSpaceTypeLoc
+    : public ConcreteTypeLoc<UnqualTypeLoc,
+                             DependentAddressSpaceTypeLoc,
+                             DependentAddressSpaceType,
+                             DependentAddressSpaceLocInfo> {
+
+  public:
+
+  /// The location of the attribute name, i.e.
+  ///    int * __attribute__((address_space(11)))
+  ///                         ^~~~~~~~~~~~~
+  SourceLocation getAttrNameLoc() const {
+    return getLocalData()->AttrLoc;
+  }
+  void setAttrNameLoc(SourceLocation loc) {
+    getLocalData()->AttrLoc = loc;
+  }
+
+  /// The attribute's expression operand, if it has one.
+  ///    int * __attribute__((address_space(11)))
+  ///                                       ^~
+  Expr *getAttrExprOperand() const {
+    return getLocalData()->ExprOperand;
+  }
+  void setAttrExprOperand(Expr *e) {
+    getLocalData()->ExprOperand = e;
+  }
+
+  /// The location of the parentheses around the operand, if there is
+  /// an operand.
+  ///    int * __attribute__((address_space(11)))
+  ///                                      ^  ^
+  SourceRange getAttrOperandParensRange() const {
+    return getLocalData()->OperandParens;
+  }
+  void setAttrOperandParensRange(SourceRange range) {
+    getLocalData()->OperandParens = range;
+  }
+
+  SourceRange getLocalSourceRange() const {
+    SourceRange range(getAttrNameLoc());
+    range.setEnd(getAttrOperandParensRange().getEnd());
+    return range;
+  }
+
+  ///  Returns the type before the address space attribute application 
+  ///  area.   
+  ///    int * __attribute__((address_space(11))) *
+  ///    ^   ^          
+  QualType getInnerType() const {
+    return this->getTypePtr()->getPointeeType();
+  }
+
+  TypeLoc getPointeeTypeLoc() const {
+    return this->getInnerTypeLoc();
+  }
+
+  void initializeLocal(ASTContext &Context, SourceLocation loc) {
+    setAttrNameLoc(loc);
+    setAttrOperandParensRange(SourceRange(loc));
+    setAttrExprOperand(getTypePtr()->getAddrSpaceExpr());
+  }
+};
+
 //===----------------------------------------------------------------------===//
 //
 //  All of these need proper implementations.

include/clang/AST/TypeNodes.def

 TYPE(VariableArray, ArrayType)
 DEPENDENT_TYPE(DependentSizedArray, ArrayType)
 DEPENDENT_TYPE(DependentSizedExtVector, Type)
+DEPENDENT_TYPE(DependentAddressSpace, Type)
 TYPE(Vector, Type)
 TYPE(ExtVector, VectorType)
 ABSTRACT_TYPE(Function, Type)

include/clang/Sema/Sema.h

                           SourceRange Brackets, DeclarationName Entity);
   QualType BuildExtVectorType(QualType T, Expr *ArraySize,
                               SourceLocation AttrLoc);
+  QualType BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace,
+                                 SourceLocation AttrLoc);
 
   bool CheckFunctionReturnType(QualType T, SourceLocation Loc);
 

include/clang/Serialization/ASTBitCodes.h

       /// \brief A DeducedTemplateSpecializationType record.
       TYPE_DEDUCED_TEMPLATE_SPECIALIZATION = 45,
       /// \brief A DependentSizedExtVectorType record.
-      TYPE_DEPENDENT_SIZED_EXT_VECTOR = 46
+      TYPE_DEPENDENT_SIZED_EXT_VECTOR = 46,
+      /// \brief A DependentAddressSpaceType record.
+      TYPE_DEPENDENT_ADDRESS_SPACE = 47
     };
 
     /// \brief The type IDs for special types constructed by semantic

lib/AST/ASTContext.cpp

   return getExtQualType(TypeNode, Quals);
 }
 
+QualType ASTContext::removeAddrSpaceQualType(QualType T) const {
+  // If we are composing extended qualifiers together, merge together
+  // into one ExtQuals node.
+  QualifierCollector Quals;
+  const Type *TypeNode = Quals.strip(T);
+
+  // If the qualifier doesn't have an address space just return it.
+  if (!Quals.hasAddressSpace())
+    return T;
+
+  Quals.removeAddressSpace();
+
+  // Removal of the address space can mean there are no longer any
+  // non-fast qualifiers, so creating an ExtQualType isn't possible (asserts)
+  // or required.
+  if (Quals.hasNonFastQualifiers())
+    return getExtQualType(TypeNode, Quals);
+  else
+    return QualType(TypeNode, Quals.getFastQualifiers());
+}
+
 QualType ASTContext::getObjCGCQualType(QualType T,
                                        Qualifiers::GC GCAttr) const {
   QualType CanT = getCanonicalType(T);

   case Type::Vector:
   case Type::ExtVector:
   case Type::DependentSizedExtVector:
+  case Type::DependentAddressSpace:
   case Type::ObjCObject:
   case Type::ObjCInterface:
   case Type::ObjCObjectPointer:

   return QualType(New, 0);
 }
 
+QualType ASTContext::getDependentAddressSpaceType(QualType PointeeType, 
+                                                  Expr *AddrSpaceExpr, 
+                                                  SourceLocation AttrLoc) const {
+  assert(AddrSpaceExpr->isInstantiationDependent()); 
+
+  QualType canonPointeeType = getCanonicalType(PointeeType);
+
+  void *insertPos = nullptr;
+  llvm::FoldingSetNodeID ID;
+  DependentAddressSpaceType::Profile(ID, *this, canonPointeeType,
+                                     AddrSpaceExpr);
+
+  DependentAddressSpaceType *canonTy =
+    DependentAddressSpaceTypes.FindNodeOrInsertPos(ID, insertPos);
+
+  if (!canonTy) {
+    canonTy = new (*this, TypeAlignment)
+      DependentAddressSpaceType(*this, canonPointeeType, 
+                                QualType(), AddrSpaceExpr, AttrLoc);
+    DependentAddressSpaceTypes.InsertNode(canonTy, insertPos);
+    Types.push_back(canonTy);
+  }
+    
+  if (canonPointeeType == PointeeType &&
+      canonTy->getAddrSpaceExpr() == AddrSpaceExpr)
+    return QualType(canonTy, 0);     
+
+  DependentAddressSpaceType *sugaredType
+    = new (*this, TypeAlignment)
+        DependentAddressSpaceType(*this, PointeeType, QualType(canonTy, 0), 
+                                  AddrSpaceExpr, AttrLoc);
+  Types.push_back(sugaredType);
+  return QualType(sugaredType, 0);  
+}
+
 /// \brief Determine whether \p T is canonical as the result type of a function.
 static bool isCanonicalResultType(QualType T) {
   return T.isCanonical() &&

lib/AST/ASTStructuralEquivalence.cpp

     break;
   }
 
+  case Type::DependentAddressSpace: {
+    const DependentAddressSpaceType *DepAddressSpace1 =
+        cast<DependentAddressSpaceType>(T1);
+    const DependentAddressSpaceType *DepAddressSpace2 =
+        cast<DependentAddressSpaceType>(T2);
+    if (!IsStructurallyEquivalent(Context, DepAddressSpace1->getAddrSpaceExpr(),
+                                  DepAddressSpace2->getAddrSpaceExpr()))
+      return false;
+    if (!IsStructurallyEquivalent(Context, DepAddressSpace1->getPointeeType(),
+                                  DepAddressSpace2->getPointeeType()))
+      return false;
+
+    break;
+  }
+
   case Type::DependentSizedExtVector: {
     const DependentSizedExtVectorType *Vec1 =
         cast<DependentSizedExtVectorType>(T1);

lib/AST/ItaniumMangle.cpp

   void mangleOperatorName(DeclarationName Name, unsigned Arity);
   void mangleOperatorName(OverloadedOperatorKind OO, unsigned Arity);
   void mangleVendorQualifier(StringRef qualifier);
-  void mangleQualifiers(Qualifiers Quals);
+  void mangleQualifiers(Qualifiers Quals, const DependentAddressSpaceType *DAST = nullptr);
   void mangleRefQualifier(RefQualifierKind RefQualifier);
 
   void mangleObjCMethodName(const ObjCMethodDecl *MD);

   case Type::IncompleteArray:
   case Type::VariableArray:
   case Type::DependentSizedArray:
+  case Type::DependentAddressSpace:
   case Type::DependentSizedExtVector:
   case Type::Vector:
   case Type::ExtVector:

   }
 }
 
-void CXXNameMangler::mangleQualifiers(Qualifiers Quals) {
+void CXXNameMangler::mangleQualifiers(Qualifiers Quals, const DependentAddressSpaceType *DAST) {
   // Vendor qualifiers come first and if they are order-insensitive they must
   // be emitted in reversed alphabetical order, see Itanium ABI 5.1.5.
 
+  // <type> ::= U <addrspace-expr>
+  if (DAST) {
+    Out << "U2ASI";
+    mangleExpression(DAST->getAddrSpaceExpr());
+    Out << "E";
+  }
+
   // Address space qualifiers start with an ordinary letter.
   if (Quals.hasAddressSpace()) {
     // Address space extension:

     // substitution at the original type.
   }
 
-  if (quals) {
-    mangleQualifiers(quals);
-    // Recurse:  even if the qualified type isn't yet substitutable,
-    // the unqualified type might be.
-    mangleType(QualType(ty, 0));
+  if (quals || ty->isDependentAddressSpaceType()) {
+    if (const DependentAddressSpaceType *DAST = 
+        dyn_cast<DependentAddressSpaceType>(ty)) {
+      SplitQualType splitDAST = DAST->getPointeeType().split();
+      mangleQualifiers(splitDAST.Quals, DAST);
+      mangleType(QualType(splitDAST.Ty, 0));
+    } else {
+      mangleQualifiers(quals);
+
+      // Recurse:  even if the qualified type isn't yet substitutable,
+      // the unqualified type might be.
+      mangleType(QualType(ty, 0));
+    }
   } else {
     switch (ty->getTypeClass()) {
 #define ABSTRACT_TYPE(CLASS, PARENT)

   mangleType(T->getElementType());
 }
 
+void CXXNameMangler::mangleType(const DependentAddressSpaceType *T) {
+  SplitQualType split = T->getPointeeType().split();
+  mangleQualifiers(split.Quals, T);
+  mangleType(QualType(split.Ty, 0));
+}
+
 void CXXNameMangler::mangleType(const PackExpansionType *T) {
   // <type>  ::= Dp <type>          # pack expansion (C++0x)
   Out << "Dp";

   // get mangled if used as an rvalue of a known non-class type?
   assert(!parm->getType()->isArrayType()
          && "parameter's type is still an array type?");
-  mangleQualifiers(parm->getType().getQualifiers());
+
+  if (const DependentAddressSpaceType *DAST =
+      dyn_cast<DependentAddressSpaceType>(parm->getType())) {
+    mangleQualifiers(DAST->getPointeeType().getQualifiers(), DAST);
+  } else {
+    mangleQualifiers(parm->getType().getQualifiers());
+  }
 
   // Parameter index.
   if (parmIndex != 0) {

lib/AST/MicrosoftMangle.cpp

     << Range;
 }
 
+void MicrosoftCXXNameMangler::mangleType(const DependentAddressSpaceType *T,
+                                         Qualifiers, SourceRange Range) {
+  DiagnosticsEngine &Diags = Context.getDiags();
+  unsigned DiagID = Diags.getCustomDiagID(
+      DiagnosticsEngine::Error,
+      "cannot mangle this dependent address space type yet");
+  Diags.Report(Range.getBegin(), DiagID) << Range;
+}
+
 void MicrosoftCXXNameMangler::mangleType(const ObjCInterfaceType *T, Qualifiers,
                                          SourceRange) {
   // ObjC interfaces have structs underlying them.

lib/AST/Type.cpp

   SizeExpr->Profile(ID, Context, true);
 }
 
+DependentAddressSpaceType::DependentAddressSpaceType(
+    const ASTContext &Context, QualType PointeeType, QualType can,
+    Expr *AddrSpaceExpr, SourceLocation loc)
+    : Type(DependentAddressSpace, can, /*Dependent=*/true,
+           /*InstantiationDependent=*/true,
+           PointeeType->isVariablyModifiedType(),
+           (PointeeType->containsUnexpandedParameterPack() ||
+            (AddrSpaceExpr &&
+             AddrSpaceExpr->containsUnexpandedParameterPack()))),
+      Context(Context), AddrSpaceExpr(AddrSpaceExpr), PointeeType(PointeeType),
+      loc(loc) {}
+
+void DependentAddressSpaceType::Profile(llvm::FoldingSetNodeID &ID,
+                                        const ASTContext &Context,
+                                        QualType PointeeType,
+                                        Expr *AddrSpaceExpr) {
+  ID.AddPointer(PointeeType.getAsOpaquePtr());
+  AddrSpaceExpr->Profile(ID, Context, true);
+}
+
 VectorType::VectorType(QualType vecType, unsigned nElements, QualType canonType,
                        VectorKind vecKind)
     : VectorType(Vector, vecType, nElements, canonType, vecKind) {}

   case Type::DependentSizedExtVector:
   case Type::Vector:
   case Type::ExtVector:
+  case Type::DependentAddressSpace:
   case Type::FunctionProto:
   case Type::FunctionNoProto:
   case Type::Record:

lib/AST/TypePrinter.cpp

     case Type::LValueReference:
     case Type::RValueReference:
     case Type::MemberPointer:
+    case Type::DependentAddressSpace:
     case Type::DependentSizedExtVector:
     case Type::Vector:
     case Type::ExtVector:

   printAfter(T->getElementType(), OS);
 }
 
+void TypePrinter::printDependentAddressSpaceBefore(
+    const DependentAddressSpaceType *T, raw_ostream &OS) {
+  printBefore(T->getPointeeType(), OS);
+}
+void TypePrinter::printDependentAddressSpaceAfter(
+    const DependentAddressSpaceType *T, raw_ostream &OS) {
+  OS << " __attribute__((address_space(";
+  if (T->getAddrSpaceExpr())
+    T->getAddrSpaceExpr()->printPretty(OS, nullptr, Policy);
+  OS << ")))";
+  printAfter(T->getPointeeType(), OS);
+}
+
 void TypePrinter::printDependentSizedExtVectorBefore(
                                           const DependentSizedExtVectorType *T, 
                                           raw_ostream &OS) { 

lib/Sema/SemaDecl.cpp

   }
 
   // TR 18037 does not allow fields to be declared with address spaces.
-  if (T.getQualifiers().hasAddressSpace()) {
+  if (T.getQualifiers().hasAddressSpace() ||
+      T->isDependentAddressSpaceType() ||
+      T->getBaseElementTypeUnsafe()->isDependentAddressSpaceType()) {
     Diag(Loc, diag::err_field_with_address_space);
     D.setInvalidType();
   }

lib/Sema/SemaTemplate.cpp

   return Visit(T->getElementType());
 }
 
+bool UnnamedLocalNoLinkageFinder::VisitDependentAddressSpaceType(
+    const DependentAddressSpaceType *T) {
+  return Visit(T->getPointeeType());
+}
+
 bool UnnamedLocalNoLinkageFinder::VisitVectorType(const VectorType* T) {
   return Visit(T->getElementType());
 }

lib/Sema/SemaTemplateDeduction.cpp

       return Sema::TDK_NonDeducedMismatch;
     }
 
+    //     (clang extension)
+    //
+    //     T __attribute__(((address_space(N))))
+    case Type::DependentAddressSpace: {
+      const DependentAddressSpaceType *AddressSpaceParam =
+          cast<DependentAddressSpaceType>(Param);
+
+      if (const DependentAddressSpaceType *AddressSpaceArg =
+              dyn_cast<DependentAddressSpaceType>(Arg)) {
+        // Perform deduction on the pointer type.
+        if (Sema::TemplateDeductionResult Result =
+                DeduceTemplateArgumentsByTypeMatch(
+                    S, TemplateParams, AddressSpaceParam->getPointeeType(),
+                    AddressSpaceArg->getPointeeType(), Info, Deduced, TDF))
+          return Result;
+
+        // Perform deduction on the address space, if we can.
+        NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(
+            Info, AddressSpaceParam->getAddrSpaceExpr());
+        if (!NTTP)
+          return Sema::TDK_Success;
+
+        return DeduceNonTypeTemplateArgument(
+            S, TemplateParams, NTTP, AddressSpaceArg->getAddrSpaceExpr(), Info,
+            Deduced);
+      }
+
+      if (Arg.getAddressSpace() >= LangAS::FirstTargetAddressSpace) {
+        llvm::APSInt ArgAddressSpace(S.Context.getTypeSize(S.Context.IntTy),
+                                     false);
+        ArgAddressSpace =
+            (Arg.getAddressSpace() - LangAS::FirstTargetAddressSpace);
+
+        // Perform deduction on the pointer types.
+        if (Sema::TemplateDeductionResult Result =
+                DeduceTemplateArgumentsByTypeMatch(
+                    S, TemplateParams, AddressSpaceParam->getPointeeType(),
+                    S.Context.removeAddrSpaceQualType(Arg), Info, Deduced, TDF))
+          return Result;
+
+        // Perform deduction on the address space, if we can.
+        NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(
+            Info, AddressSpaceParam->getAddrSpaceExpr());
+        if (!NTTP)
+          return Sema::TDK_Success;
+
+        return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
+                                             ArgAddressSpace, S.Context.IntTy,
+                                             true, Info, Deduced);
+      }
+
+      return Sema::TDK_NonDeducedMismatch;
+    }
+
     case Type::TypeOfExpr:
     case Type::TypeOf:
     case Type::DependentName:

     break;
   }
 
+  case Type::DependentAddressSpace: {
+    const DependentAddressSpaceType *DependentASType =
+        cast<DependentAddressSpaceType>(T);
+    MarkUsedTemplateParameters(Ctx, DependentASType->getPointeeType(),
+                               OnlyDeduced, Depth, Used);
+    MarkUsedTemplateParameters(Ctx,
+                               DependentASType->getAddrSpaceExpr(),
+                               OnlyDeduced, Depth, Used);
+    break;
+  }
+
   case Type::FunctionProto: {
     const FunctionProtoType *Proto = cast<FunctionProtoType>(T);
     MarkUsedTemplateParameters(Ctx, Proto->getReturnType(), OnlyDeduced, Depth,

lib/Sema/SemaType.cpp

   ATL.setParensRange(SourceRange());
 }
 
+static void fillDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc DASTL, 
+                                             const AttributeList *Attrs) {
+  while (Attrs && Attrs->getKind() != AttributeList::AT_AddressSpace)
+    Attrs = Attrs->getNext();
+
+  assert(Attrs && "no address_space attribute found at the expected location!");
+  
+  DASTL.setAttrNameLoc(Attrs->getLoc());
+  DASTL.setAttrExprOperand(Attrs->getArgAsExpr(0));
+  DASTL.setAttrOperandParensRange(SourceRange());
+}
+
 /// \brief Create and instantiate a TypeSourceInfo with type source information.
 ///
 /// \param T QualType referring to the type as written in source code.

   }
 
   for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
+    
+    if (DependentAddressSpaceTypeLoc DASTL =
+        CurrTL.getAs<DependentAddressSpaceTypeLoc>()) {
+      fillDependentAddressSpaceTypeLoc(DASTL, D.getTypeObject(i).getAttrs());
+      CurrTL = DASTL.getPointeeTypeLoc().getUnqualifiedLoc();  
+    }
+
     // An AtomicTypeLoc might be produced by an atomic qualifier in this
     // declarator chunk.
     if (AtomicTypeLoc ATL = CurrTL.getAs<AtomicTypeLoc>()) {

 // Type Attribute Processing
 //===----------------------------------------------------------------------===//
 
+/// BuildAddressSpaceAttr - Builds a DependentAddressSpaceType if an expression 
+/// is uninstantiated. If instantiated it will apply the appropriate address space 
+/// to the type. This function allows dependent template variables to be used in
+/// conjunction with the address_space attribute  
+QualType Sema::BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace,
+                                     SourceLocation AttrLoc) {
+  if (!AddrSpace->isValueDependent()) { 
+
+    // If this type is already address space qualified, reject it.
+    // ISO/IEC TR 18037 S5.3 (amending C99 6.7.3): "No type shall be qualified
+    // by qualifiers for two or more different address spaces."
+    if (T.getAddressSpace()) {
+      Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
+      return QualType();
+    }
+
+    llvm::APSInt addrSpace(32);
+    if (!AddrSpace->isIntegerConstantExpr(addrSpace, Context)) {
+      Diag(AttrLoc, diag::err_attribute_argument_type)
+          << "'address_space'" << AANT_ArgumentIntegerConstant
+          << AddrSpace->getSourceRange();
+      return QualType();
+    }
+
+    // Bounds checking.
+    if (addrSpace.isSigned()) {
+      if (addrSpace.isNegative()) {
+        Diag(AttrLoc, diag::err_attribute_address_space_negative)
+            << AddrSpace->getSourceRange();
+        return QualType();
+      }
+      addrSpace.setIsSigned(false);
+    }
+
+    llvm::APSInt max(addrSpace.getBitWidth());
+    max = Qualifiers::MaxAddressSpace - LangAS::FirstTargetAddressSpace;
+    if (addrSpace > max) {
+      Diag(AttrLoc, diag::err_attribute_address_space_too_high)
+          << (unsigned)max.getZExtValue() << AddrSpace->getSourceRange();
+      return QualType();
+    }
+
+    unsigned ASIdx = static_cast<unsigned>(addrSpace.getZExtValue()) +
+                     LangAS::FirstTargetAddressSpace;
+
+    return Context.getAddrSpaceQualType(T, ASIdx);
+  }
+
+  // A check with similar intentions as checking if a type already has an
+  // address space except for on a dependent types, basically if the 
+  // current type is already a DependentAddressSpaceType then its already 
+  // lined up to have another address space on it and we can't have
+  // multiple address spaces on the one pointer indirection
+  if (T->getAs<DependentAddressSpaceType>()) {
+    Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
+    return QualType();
+  }
+
+  return Context.getDependentAddressSpaceType(T, AddrSpace, AttrLoc);
+}
+
 /// HandleAddressSpaceTypeAttribute - Process an address_space attribute on the
 /// specified type.  The attribute contains 1 argument, the id of the address
 /// space for the type.

 
   unsigned ASIdx;
   if (Attr.getKind() == AttributeList::AT_AddressSpace) {
+
     // Check the attribute arguments.
     if (Attr.getNumArgs() != 1) {
       S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
           << Attr.getName() << 1;
-      Attr.setInvalid();
-      return;
-    }
-    Expr *ASArgExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
-    llvm::APSInt addrSpace(32);
-    if (ASArgExpr->isTypeDependent() || ASArgExpr->isValueDependent() ||
-        !ASArgExpr->isIntegerConstantExpr(addrSpace, S.Context)) {
-      S.Diag(Attr.getLoc(), diag::err_attribute_argument_type)
-        << Attr.getName() << AANT_ArgumentIntegerConstant
-        << ASArgExpr->getSourceRange();
       Attr.setInvalid();
       return;
     }
 
-    // Bounds checking.
-    if (addrSpace.isSigned()) {
-      if (addrSpace.isNegative()) {
-        S.Diag(Attr.getLoc(), diag::err_attribute_address_space_negative)
-          << ASArgExpr->getSourceRange();
-        Attr.setInvalid();
+    Expr *ASArgExpr;
+    if (Attr.isArgIdent(0)) {
+      // Special case where the argument is a template id.
+      CXXScopeSpec SS;
+      SourceLocation TemplateKWLoc;
+      UnqualifiedId id;
+      id.setIdentifier(Attr.getArgAsIdent(0)->Ident, Attr.getLoc());
+
+      ExprResult AddrSpace = S.ActOnIdExpression(
+          S.getCurScope(), SS, TemplateKWLoc, id, false, false);
+      if (AddrSpace.isInvalid())
         return;
-      }
-      addrSpace.setIsSigned(false);
+
+      ASArgExpr = static_cast<Expr *>(AddrSpace.get());
+    } else {
+      ASArgExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
     }
-    llvm::APSInt max(addrSpace.getBitWidth());
-    max = Qualifiers::MaxAddressSpace - LangAS::FirstTargetAddressSpace;
-    if (addrSpace > max) {
-      S.Diag(Attr.getLoc(), diag::err_attribute_address_space_too_high)
-        << (unsigned)max.getZExtValue() << ASArgExpr->getSourceRange();
+
+    // Create the DependentAddressSpaceType or append an address space onto
+    // the type.
+    QualType T = S.BuildAddressSpaceAttr(Type, ASArgExpr, Attr.getLoc());
+
+    if (!T.isNull())
+      Type = T;
+    else
       Attr.setInvalid();
-      return;
-    }
-    ASIdx = static_cast<unsigned>(addrSpace.getZExtValue()) +
-            LangAS::FirstTargetAddressSpace;
   } else {
     // The keyword-based type attributes imply which address space to use.
     switch (Attr.getKind()) {

       assert(Attr.getKind() == AttributeList::AT_OpenCLPrivateAddressSpace);
       ASIdx = 0; break;
     }
+
+    Type = S.Context.getAddrSpaceQualType(Type, ASIdx);
   }
-  
-  Type = S.Context.getAddrSpaceQualType(Type, ASIdx);
 }
 
 /// Does this type have a "direct" ownership qualifier?  That is,

lib/Sema/TreeTransform.h

                                               Expr *SizeExpr,
                                               SourceLocation AttributeLoc);
 
+  /// \brief Build a new DependentAddressSpaceType or return the pointee
+  /// type variable with the correct address space (retrieved from
+  /// AddrSpaceExpr) applied to it. The former will be returned in cases
+  /// where the address space remains dependent.
+  ///
+  /// By default, performs semantic analysis when building the type with address
+  /// space applied. Subclasses may override this routine to provide different
+  /// behavior.
+  QualType RebuildDependentAddressSpaceType(QualType PointeeType,
+                                            Expr *AddrSpaceExpr,
+                                            SourceLocation AttributeLoc);
+
   /// \brief Build a new function type.
   ///
   /// By default, performs semantic analysis when building the function type.

   return Result;
 }
 
-template<typename Derived>
+template <typename Derived>
+QualType TreeTransform<Derived>::TransformDependentAddressSpaceType(
+    TypeLocBuilder &TLB, DependentAddressSpaceTypeLoc TL) {
+  const DependentAddressSpaceType *T = TL.getTypePtr();
+
+  QualType pointeeType = getDerived().TransformType(T->getPointeeType());
+
+  if (pointeeType.isNull())
+    return QualType();
+
+  // Address spaces are constant expressions.
+  EnterExpressionEvaluationContext Unevaluated(
+      SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
+
+  ExprResult AddrSpace = getDerived().TransformExpr(T->getAddrSpaceExpr());
+  AddrSpace = SemaRef.ActOnConstantExpression(AddrSpace);
+  if (AddrSpace.isInvalid())
+    return QualType();
+
+  QualType Result = TL.getType();
+  if (getDerived().AlwaysRebuild() || pointeeType != T->getPointeeType() ||
+      AddrSpace.get() != T->getAddrSpaceExpr()) {
+    Result = getDerived().RebuildDependentAddressSpaceType(
+        pointeeType, AddrSpace.get(), T->getAttributeLoc());
+    if (Result.isNull())
+      return QualType();
+  }
+
+  // Result might be dependent or not.
+  if (isa<DependentAddressSpaceType>(Result)) {
+    DependentAddressSpaceTypeLoc NewTL =
+        TLB.push<DependentAddressSpaceTypeLoc>(Result);
+
+    NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
+    NewTL.setAttrExprOperand(TL.getAttrExprOperand());
+    NewTL.setAttrNameLoc(TL.getAttrNameLoc());
+
+  } else {
+    TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(
+        Result, getDerived().getBaseLocation());
+    TransformType(TLB, DI->getTypeLoc());
+  }
+
+  return Result;
+}
+
+template <typename Derived>
 QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
                                                      VectorTypeLoc TL) {
   const VectorType *T = TL.getTypePtr();

                                        IndexTypeQuals, BracketsRange);
 }
 
-template<typename Derived>
-QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType,
-                                               unsigned NumElements,
-                                               VectorType::VectorKind VecKind) {
+template <typename Derived>
+QualType TreeTransform<Derived>::RebuildDependentAddressSpaceType(
+    QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttributeLoc) {
+  return SemaRef.BuildAddressSpaceAttr(PointeeType, AddrSpaceExpr,
+                                          AttributeLoc);
+}
+
+template <typename Derived>
+QualType
+TreeTransform<Derived>::RebuildVectorType(QualType ElementType,
+                                          unsigned NumElements,
+                                          VectorType::VectorKind VecKind) {
   // FIXME: semantic checking!
   return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind);
 }

lib/Serialization/ASTReader.cpp

     return Context.getDependentSizedExtVectorType(ElementType, SizeExpr,
                                                   AttrLoc);
   }
+
+  case TYPE_DEPENDENT_ADDRESS_SPACE: {
+    unsigned Idx = 0;
+
+    // DependentAddressSpaceType
+    QualType PointeeType = readType(*Loc.F, Record, Idx);
+    Expr *AddrSpaceExpr = ReadExpr(*Loc.F);
+    SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
+
+    return Context.getDependentAddressSpaceType(PointeeType, AddrSpaceExpr,
+                                                   AttrLoc);
+  }
   }
   llvm_unreachable("Invalid TypeCode!");
 }

   VisitArrayTypeLoc(TL);
 }
 
+void TypeLocReader::VisitDependentAddressSpaceTypeLoc(
+    DependentAddressSpaceTypeLoc TL) {
+
+    TL.setAttrNameLoc(ReadSourceLocation());
+    SourceRange range;
+    range.setBegin(ReadSourceLocation());
+    range.setEnd(ReadSourceLocation());
+    TL.setAttrOperandParensRange(range);
+    TL.setAttrExprOperand(Reader->ReadExpr(*F));
+}
+
 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
                                         DependentSizedExtVectorTypeLoc TL) {
   TL.setNameLoc(ReadSourceLocation());

lib/Serialization/ASTWriter.cpp

   Code = TYPE_DEPENDENT_SIZED_EXT_VECTOR;
 }
 
+void 
+ASTTypeWriter::VisitDependentAddressSpaceType(
+    const DependentAddressSpaceType *T) {
+  Record.AddTypeRef(T->getPointeeType());
+  Record.AddStmt(T->getAddrSpaceExpr());
+  Record.AddSourceLocation(T->getAttributeLoc());
+  Code = TYPE_DEPENDENT_ADDRESS_SPACE;
+}
+
 void
 ASTTypeWriter::VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
   Record.push_back(T->getDepth());

   VisitArrayTypeLoc(TL);
 }
 
+void TypeLocWriter::VisitDependentAddressSpaceTypeLoc(
+    DependentAddressSpaceTypeLoc TL) {
+  Record.AddSourceLocation(TL.getAttrNameLoc());
+  SourceRange range = TL.getAttrOperandParensRange();
+  Record.AddSourceLocation(range.getBegin());
+  Record.AddSourceLocation(range.getEnd());
+  Record.AddStmt(TL.getAttrExprOperand());       
+}
+
 void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc(
                                         DependentSizedExtVectorTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());

test/SemaTemplate/address_space-dependent.cpp

+// RUN: %clang_cc1 -x c++ -std=c++14 -fsyntax-only -verify %s
+
+template <int I, int J, int K>
+void car() {
+  int __attribute__((address_space(I))) __attribute__((address_space(J))) * Y;  // expected-error {{multiple address spaces specified for type}}
+  int *__attribute__((address_space(I))) __attribute__((address_space(J))) * Z; // expected-error {{multiple address spaces specified for type}}
+
+  __attribute__((address_space(I))) int local;        // expected-error {{automatic variable qualified with an address space}}
+  __attribute__((address_space(J))) int array[5];     // expected-error {{automatic variable qualified with an address space}}
+  __attribute__((address_space(I))) int arrarr[5][5]; // expected-error {{automatic variable qualified with an address space}}
+
+  __attribute__((address_space(J))) * x; // expected-error {{C++ requires a type specifier for all declarations}}
+
+  __attribute__((address_space(I))) float *B;
+
+  typedef __attribute__((address_space(J))) int AS2Int;
+  struct HasASFields {
+    AS2Int typedef_as_field; // expected-error {{field may not be qualified with an address space}}
+  };
+
+  struct _st {
+    int x, y;
+  } s __attribute((address_space(I))) = {1, 1};
+}
+
+template <int I>
+struct HasASTemplateFields {
+  __attribute__((address_space(I))) int as_field; // expected-error {{field may not be qualified with an address space}}
+};
+
+template <int I, int J>
+void foo(__attribute__((address_space(I))) float *a, // expected-note {{candidate template ignored: substitution failure [with I = 1, J = 2]: parameter may not be qualified with an address space}}
+         __attribute__((address_space(J))) float b) {
+  *a = 5.0f + b;
+}
+
+template void foo<1, 2>(float *, float); // expected-error {{explicit instantiation of 'foo' does not refer to a function template, variable template, member function, member class, or static data member}}
+
+template <int I>
+void neg() {
+  __attribute__((address_space(I))) int *bounds; // expected-error {{address space is negative}}
+}
+
+template <long int I>
+void toBig() {
+  __attribute__((address_space(I))) int *bounds; // expected-error {{address space is larger than the maximum supported (8388599)}}
+}
+
+template <long int I>
+void correct() {
+  __attribute__((address_space(I))) int *bounds;
+}
+
+template <int I, int J>
+char *cmp(__attribute__((address_space(I))) char *x, __attribute__((address_space(J))) char *y) {
+  return x < y ? x : y; // expected-error {{comparison of distinct pointer types ('__attribute__((address_space(1))) char *' and '__attribute__((address_space(2))) char *')}}
+}
+
+typedef void ft(void);
+
+template <int I>
+struct fooFunction {
+  __attribute__((address_space(I))) void **const base = 0;
+
+  void *get_0(void) {
+    return base[0]; // expected-error {{cannot initialize return object of type 'void *' with an lvalue of type '__attribute__((address_space(1))) void *}}
+  }
+
+  __attribute__((address_space(I))) ft qf; // expected-error {{function type may not be qualified with an address space}}
+  __attribute__((address_space(I))) char *test3_val;
+
+  void test3(void) {
+    extern void test3_helper(char *p); // expected-note {{passing argument to parameter 'p' here}}
+    test3_helper(test3_val);           // expected-error {{cannot initialize a parameter of type 'char *' with an lvalue of type '__attribute__((address_space(1))) char *'}}
+  }
+};
+
+template <typename T, int N>
+int GetAddressSpaceValue(T __attribute__((address_space(N))) * p) {
+  return N;
+}
+
+template <unsigned A> int __attribute__((address_space(A))) *same_template();
+template <unsigned B> int __attribute__((address_space(B))) *same_template();
+void test_same_template() { (void) same_template<0>(); }
+
+template <unsigned A> int __attribute__((address_space(A))) *different_template(); // expected-note {{candidate function [with A = 0]}}
+template <unsigned B> int __attribute__((address_space(B+1))) *different_template(); // expected-note {{candidate function [with B = 0]}}
+void test_different_template() { (void) different_template<0>(); } // expected-error {{call to 'different_template' is ambiguous}}
+
+template <typename T> struct partial_spec_deduce_as;
+template <typename T, unsigned AS> 
+struct partial_spec_deduce_as <__attribute__((address_space(AS))) T *> {
+   static const unsigned value = AS;  
+}; 
+
+int main() {  
+  int __attribute__((address_space(1))) * p1;
+  int p = GetAddressSpaceValue(p1);
+
+  car<1, 2, 3>(); // expected-note {{in instantiation of function template specialization 'car<1, 2, 3>' requested here}}
+  HasASTemplateFields<1> HASTF;
+  neg<-1>(); // expected-note {{in instantiation of function template specialization 'neg<-1>' requested here}}
+  correct<0x7FFFF7>();
+  toBig<4294967500>(); // expected-note {{in instantiation of function template specialization 'toBig<4294967500>' requested here}}
+
+  __attribute__((address_space(1))) char *x;
+  __attribute__((address_space(2))) char *y;
+  cmp<1, 2>(x, y); // expected-note {{in instantiation of function template specialization 'cmp<1, 2>' requested here}}
+
+  fooFunction<1> ff;
+  ff.get_0(); // expected-note {{in instantiation of member function 'fooFunction<1>::get_0' requested here}}
+  ff.qf();
+  ff.test3(); // expected-note {{in instantiation of member function 'fooFunction<1>::test3' requested here}}
+  
+  static_assert(partial_spec_deduce_as<int __attribute__((address_space(3))) *>::value == 3, "address space value has been incorrectly deduced"); 
+
+  return 0;
+}

tools/libclang/CIndex.cpp

 DEFAULT_TYPELOC_IMPL(IncompleteArray, ArrayType)
 DEFAULT_TYPELOC_IMPL(VariableArray, ArrayType)
 DEFAULT_TYPELOC_IMPL(DependentSizedArray, ArrayType)
+DEFAULT_TYPELOC_IMPL(DependentAddressSpace, Type)
 DEFAULT_TYPELOC_IMPL(DependentSizedExtVector, Type)
 DEFAULT_TYPELOC_IMPL(Vector, Type)
 DEFAULT_TYPELOC_IMPL(ExtVector, VectorType)