Set address space when emitting debug info

lib/CodeGen/CGDebugInfo.cpp

llvm::DIType *CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag,
   // Bit size, align and offset of the type.
   // Size is always the size of a pointer. We can't use getTypeSize here
   // because that does not return the correct value for references.
   unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy);
   uint64_t Size = CGM.getTarget().getPointerWidth(AS);
   uint64_t Align = CGM.getContext().getTypeAlign(Ty);
 
   return DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size,
-                                    Align);
+                                    Align, AS);
 }
 
 llvm::DIType *CGDebugInfo::getOrCreateStructPtrType(StringRef Name,
                                                     llvm::DIType *&Cache) {
   if (Cache)
     return Cache;
   Cache = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, Name,
                                      TheCU, getOrCreateMainFile(), 0);
llvm::DIType *CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile *Unit) {
   ASTContext &Context = CGM.getContext();
 
   /* Function type */
   llvm::Metadata *STy = getOrCreateType(Context.IntTy, Unit);
   llvm::DITypeRefArray SElements = DBuilder.getOrCreateTypeArray(STy);
   llvm::DIType *SubTy = DBuilder.createSubroutineType(Unit, SElements);
   unsigned Size = Context.getTypeSize(Context.VoidPtrTy);
   llvm::DIType *vtbl_ptr_type =
-      DBuilder.createPointerType(SubTy, Size, 0, "__vtbl_ptr_type");
+    DBuilder.createPointerType(SubTy, Size, 0, 0, "__vtbl_ptr_type");
   VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size);
   return VTablePtrType;
 }
 
 StringRef CGDebugInfo::getVTableName(const CXXRecordDecl *RD) {
   // Copy the gdb compatible name on the side and use its reference.
   return internString("_vptr$", RD->getNameAsString());
 }

test/CodeGenOpenCL/addrspace-debug-info.cl

+// RUN: %clang_cc1 -cl-std=CL2.0 -g -triple amdgcn-unknown-amdhsa -S -emit-llvm -o - %s | FileCheck %s
+
+// FIXME: generic pointer getting wrong address space.
+
+
+// CHECK-DAG: ![[GLOBALPTRTYPE:[0-9]+]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !{{[0-9]+}}, size: 64, align: 32, extraData: i32 1)
+// CHECK-DAG: ![[CONSTANTPTRTYPE:[0-9]+]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !{{[0-9]+}}, size: 64, align: 32, extraData: i32 2)
+// CHECK-DAG: ![[LOCALPTRTYPE:[0-9]+]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !{{[0-9]+}}, size: 32, align: 32, extraData: i32 3)
+// CHECK-DAG: ![[PRIVATEPTRTYPE:[0-9]+]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !{{[0-9]+}}, size: 32, align: 32)
+
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "globalptr_arg", arg: 1, scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: ![[GLOBALPTRTYPE]])
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "constantptr_arg", arg: 2, scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: ![[CONSTANTPTRTYPE]])
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "localptr_arg", arg: 3, scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: ![[LOCALPTRTYPE]])
+
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "privateptr", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: ![[PRIVATEPTRTYPE]]
+
+// FIXME: This should not be the same as the private pointer type.
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "genericptr", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: ![[PRIVATEPTRTYPE]]
+
+// CHECK-DAG: !DIDerivedType(tag: DW_TAG_member, name: "memberptr", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: ![[CONSTANTPTRTYPE]], size: 64, align: 32)
+
+kernel void ptr_types_debuginfo(global int* globalptr_arg,
+                                constant int* constantptr_arg,
+                                local int* localptr_arg)
+{
+    private int* privateptr = 0;
+    int* genericptr = 0;
+}
+
+struct Foo {
+  constant int* memberptr;
+};
+
+// FIXME: Address space for global variable seems to not be represented?
+constant int gconstint = 2;
+constant struct Foo globalstruct = { &gconstint };