[DebugInfo] Update tests to use opaque ptrs

test/DebugInfo/EagerTypeMetadata.swift

@@ -1,13 +1,12 @@
-// RUN: %target-swift-frontend %use_no_opaque_pointers %s -Onone -emit-ir -g -o - | %FileCheck %s
-// RUN: %target-swift-frontend %s -Onone -emit-ir -g -o -
+// RUN: %target-swift-frontend %s -Onone -emit-ir -g -o - | %FileCheck %s
 
 public class C<T>
 {
   func c(_ i : T)
   {
     // Ensure that the type metadata for T is eagerly loaded at -Onone.
     // CHECK: define {{.*}} @"$s17EagerTypeMetadata1CC1cyyxF"
-    // CHECK: %T = load %swift.type*, %swift.type**
+    // CHECK: %T = load ptr, ptr
     // CHECK-SAME: !dbg ![[LOC:[0-9]+]], !invariant.load
     var x = [i]
   }

test/DebugInfo/LoadableByAddress-allockstack.swift

@@ -1,13 +1,9 @@
 // Check we don't crash when verifying debug info.
 // Ideally this should print the output after loadable by address runs
 // but there's no way of doing this in SIL (for IRGen passes).
-// RUN: %target-swift-frontend %use_no_opaque_pointers -emit-sil %s -Onone \
-// RUN:   -sil-verify-all -Xllvm -verify-di-holes -emit-ir \
-// RUN:   -Xllvm -sil-print-debuginfo -g -o - | %FileCheck %s
-
 // RUN: %target-swift-frontend -emit-sil %s -Onone \
 // RUN:   -sil-verify-all -Xllvm -verify-di-holes -emit-ir \
-// RUN:   -Xllvm -sil-print-debuginfo -g -o -
+// RUN:   -Xllvm -sil-print-debuginfo -g -o - | %FileCheck %s
 
 struct m {
   let major: Int
@@ -50,4 +46,4 @@ struct h<i>{
   }
 }
 
-// CHECK: define internal %swift.opaque* @"$s4main1mVwCP"
+// CHECK: define internal ptr @"$s4main1mVwCP"

test/DebugInfo/ProtocolContainer.swift

@@ -1,5 +1,4 @@
-// RUN: %target-swift-frontend %use_no_opaque_pointers %s -emit-ir -g -o - | %FileCheck %s
-// RUN: %target-swift-frontend %s -emit-ir -g -o -
+// RUN: %target-swift-frontend %s -emit-ir -g -o - | %FileCheck %s
 
 func markUsed<T>(_ t: T) {}
 
@@ -15,7 +14,7 @@ class AClass : AProtocol {
 // CHECK: define hidden {{.*}}void @"$s17ProtocolContainer3foo{{[_0-9a-zA-Z]*}}F"
 // CHECK-NEXT: entry:
 // CHECK:      %[[X:.*]] = alloca %T17ProtocolContainer9AProtocolP, align {{(4|8)}}
-// CHECK:      call void @llvm.dbg.declare(metadata %T17ProtocolContainer9AProtocolP* %[[X]], metadata ![[XMD:.*]], metadata !DIExpression())
+// CHECK:      call void @llvm.dbg.declare(metadata ptr %[[X]], metadata ![[XMD:.*]], metadata !DIExpression())
 // CHECK-NOT: !DILocalVariable({{.*}} name: "x"
 // CHECK-NOT: !DILocalVariable({{.*}} name: "x"
 func foo (_ x : AProtocol) {

test/DebugInfo/WeakCapture.swift

@@ -1,5 +1,4 @@
-// RUN: %target-swift-frontend %use_no_opaque_pointers %s -emit-ir -g -o - | %FileCheck %s
-// RUN: %target-swift-frontend %s -emit-ir -g -o -
+// RUN: %target-swift-frontend %s -emit-ir -g -o - | %FileCheck %s
 class A {
     init(handler: (() -> ())) { }
 }
@@ -11,9 +10,9 @@ func function() {
     let b = B()
 
   // Ensure that the local b and its weak copy are distinct local variables.
-  // CHECK: call void @llvm.dbg.{{.*}}(metadata %T11WeakCapture1BC*
+  // CHECK: call void @llvm.dbg.{{.*}}(metadata ptr
   // CHECK-SAME:                       metadata [[B:.*]], metadata
-  // CHECK: call void @llvm.dbg.{{.*}}(metadata %swift.weak*
+  // CHECK: call void @llvm.dbg.{{.*}}(metadata ptr
   // CHECK-NOT:                        metadata [[B]]
   // CHECK: call
     A(handler: { [weak b] in

test/DebugInfo/any.swift

@@ -1,10 +1,10 @@
-// RUN: %target-swift-frontend %use_no_opaque_pointers %s -emit-ir -g -o - | %FileCheck %s
-// RUN: %target-swift-frontend %s -emit-ir -g -o -
+// RUN: %target-swift-frontend %s -emit-ir -g -o - | %FileCheck %s
 
 func markUsed<T>(_ t: T) {}
 
 func main() {
-  // CHECK: call void @llvm.dbg.declare(metadata %Any* {{.*}}, metadata ![[S:.*]], metadata !DIExpression()), !dbg ![[DBG:.*]]
+	// CHECK: define hidden swiftcc void @"$s3any4mainyyF"
+  // CHECK: call void @llvm.dbg.declare(metadata ptr {{.*}}, metadata ![[S:.*]], metadata !DIExpression()), !dbg ![[DBG:.*]]
   // CHECK: ![[S]] = !DILocalVariable(name: "s", {{.*}}line: [[@LINE+2]]
   // CHECK: ![[DBG]] = !DILocation(line: [[@LINE+1]], column: 7,
   var s: Any = "hello world"

test/DebugInfo/async-args.swift

@@ -1,10 +1,6 @@
-// RUN: %target-swift-frontend %use_no_opaque_pointers %s -emit-ir -g -o - \
-// RUN:    -module-name M  -disable-availability-checking \
-// RUN:    -parse-as-library | %FileCheck %s
-
 // RUN: %target-swift-frontend %s -emit-ir -g -o - \
 // RUN:    -module-name M  -disable-availability-checking \
-// RUN:    -parse-as-library
+// RUN:    -parse-as-library | %FileCheck %s
 
 // REQUIRES: concurrency
 
@@ -14,14 +10,14 @@ func forceSplit() async {
 func withGenericArg<T>(_ msg: T) async {
   // This odd debug info is part of a contract with CoroSplit/CoroFrame to fix
   // this up after coroutine splitting.
-  // CHECK-LABEL: {{^define .*}} @"$s1M14withGenericArgyyxYalF"(%swift.context* swiftasync %0
-  // CHECK-DAG: call void @llvm.dbg.declare(metadata %swift.context* %0, metadata ![[MSG:[0-9]+]], metadata !DIExpression({{.*}}DW_OP_plus_uconst, {{.*}}DW_OP_deref))
-  // CHECK-DAG: call void @llvm.dbg.declare(metadata %swift.context* %0, metadata ![[TAU:[0-9]+]], metadata !DIExpression({{.*}}DW_OP_plus_uconst,
+  // CHECK-LABEL: {{^define .*}} @"$s1M14withGenericArgyyxYalF"(ptr swiftasync %0
+  // CHECK-DAG: call void @llvm.dbg.declare(metadata ptr %0, metadata ![[MSG:[0-9]+]], metadata !DIExpression({{.*}}DW_OP_plus_uconst, {{.*}}DW_OP_deref))
+  // CHECK-DAG: call void @llvm.dbg.declare(metadata ptr %0, metadata ![[TAU:[0-9]+]], metadata !DIExpression({{.*}}DW_OP_plus_uconst,
 
   await forceSplit()
-  // CHECK-LABEL: {{^define .*}} @"$s1M14withGenericArgyyxYalFTQ0_"(i8* swiftasync %0)
-  // CHECK-DAG: call void @llvm.dbg.declare(metadata i8* %0, metadata ![[MSG_R:[0-9]+]], metadata !DIExpression({{.*}}DW_OP_plus_uconst, [[OFFSET:[0-9]+]], DW_OP_plus_uconst, {{[0-9]+}}, DW_OP_deref))
-  // CHECK-DAG: call void @llvm.dbg.declare(metadata i8* %0, metadata ![[TAU_R:[0-9]+]], metadata !DIExpression({{.*}}DW_OP_deref, DW_OP_plus_uconst, [[OFFSET]], DW_OP_plus_uconst, {{[0-9]+}}))
+  // CHECK-LABEL: {{^define .*}} @"$s1M14withGenericArgyyxYalFTQ0_"(ptr swiftasync %0)
+  // CHECK-DAG: call void @llvm.dbg.declare(metadata ptr %0, metadata ![[MSG_R:[0-9]+]], metadata !DIExpression({{.*}}DW_OP_plus_uconst, [[OFFSET:[0-9]+]], DW_OP_plus_uconst, {{[0-9]+}}, DW_OP_deref))
+  // CHECK-DAG: call void @llvm.dbg.declare(metadata ptr %0, metadata ![[TAU_R:[0-9]+]], metadata !DIExpression({{.*}}DW_OP_deref, DW_OP_plus_uconst, [[OFFSET]], DW_OP_plus_uconst, {{[0-9]+}}))
   use(msg)
 }
 // CHECK-LABEL: {{^define }}

test/DebugInfo/async-let-await.swift

@@ -1,10 +1,6 @@
-// RUN: %target-swift-frontend %use_no_opaque_pointers %s -emit-ir -g -o - \
-// RUN:    -module-name M  -disable-availability-checking \
-// RUN:    -parse-as-library | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize
-
 // RUN: %target-swift-frontend %s -emit-ir -g -o - \
 // RUN:    -module-name M  -disable-availability-checking \
-// RUN:    -parse-as-library
+// RUN:    -parse-as-library | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize
 
 // REQUIRES: concurrency
 
@@ -16,7 +12,7 @@ public func getVegetables() async -> [String] {
 public func chopVegetables() async throws -> [String] {
   let veggies = await getVegetables()
   // CHECK-NOT: {{^define }}
-  // CHECK:  call void @llvm.dbg.declare(metadata i8* %0, metadata ![[V:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, {{[0-9]+}}, DW_OP_plus_uconst, {{[0-9]+}})
+  // CHECK:  call void @llvm.dbg.declare(metadata ptr %0, metadata ![[V:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, {{[0-9]+}}, DW_OP_plus_uconst, {{[0-9]+}})
   // CHECK: ![[V]] = !DILocalVariable(name: "veggies"
   return veggies.map { "chopped \($0)" }
 }

test/DebugInfo/async-let.swift

@@ -1,27 +1,23 @@
-// RUN: %target-swift-frontend %use_no_opaque_pointers %s -emit-ir -g -o - \
-// RUN:    -module-name M  -disable-availability-checking \
-// RUN:    -parse-as-library | %FileCheck %s --check-prefix=CHECK
-
 // RUN: %target-swift-frontend %s -emit-ir -g -o - \
 // RUN:    -module-name M  -disable-availability-checking \
-// RUN:    -parse-as-library
+// RUN:    -parse-as-library | %FileCheck %s --check-prefix=CHECK
 
 // REQUIRES: concurrency
 
 public actor Alice {
   let bob = Bob()
 
   // CHECK: define {{.*}}$s1M5AliceC4callyyYaFTY0_{{.*}} !dbg ![[SCOPE0:[0-9]+]]
-  // CHECK: call i8* @__swift_async_resume_get_context{{.*}}!dbg ![[HOP0:[0-9]+]]
+  // CHECK: call ptr @__swift_async_resume_get_context{{.*}}!dbg ![[HOP0:[0-9]+]]
 
   // CHECK: define {{.*}}$s1M5AliceC4callyyYaFTY1_{{.*}} !dbg ![[SCOPE1:[0-9]+]]
-  // CHECK: call i8* @__swift_async_resume_get_context{{.*}}!dbg ![[HOP1:[0-9]+]]
+  // CHECK: call ptr @__swift_async_resume_get_context{{.*}}!dbg ![[HOP1:[0-9]+]]
 
   // CHECK: define {{.*}}$s1M5AliceC4callyyYaFSiyYaYbcfu_TY0_{{.*}} !dbg ![[LET_SCOPE0:[0-9]+]]
-  // CHECK: call i8* @__swift_async_resume_get_context{{.*}}!dbg ![[LET_HOP0:[0-9]+]]
+  // CHECK: call ptr @__swift_async_resume_get_context{{.*}}!dbg ![[LET_HOP0:[0-9]+]]
 
   // CHECK: define {{.*}}$s1M5AliceC4callyyYaFSiyYaYbcfu_TY2_{{.*}} !dbg ![[LET_SCOPE1:[0-9]+]]
-  // CHECK: call i8* @__swift_async_resume_get_context{{.*}}!dbg ![[LET_HOP1:[0-9]+]]
+  // CHECK: call ptr @__swift_async_resume_get_context{{.*}}!dbg ![[LET_HOP1:[0-9]+]]
   public func call() async {
     // CHECK: ![[SCOPE0]] = distinct !DISubprogram({{.*}}line: [[@LINE-1]]
     // CHECK: ![[HOP0]] = !DILocation(line: [[@LINE-2]], column: 15

test/DebugInfo/basic.swift

@@ -20,23 +20,19 @@
 // CHECK-LINETABLES-NOT: DIBasicType
 // --------------------------------------------------------------------
 // Now check that we do generate line+scope info with -g.
-// RUN: %target-swift-frontend %use_no_opaque_pointers %/s -emit-ir -g -o - \
+// RUN: %target-swift-frontend %/s -emit-ir -g -o - \
 // RUN:   | %FileCheck %s --check-prefixes CHECK,DWARF-CHECK
-// RUN: %target-swift-frontend %/s -emit-ir -g -o -
 // --------------------------------------------------------------------
 // Currently -gdwarf-types should give the same results as -g.
-// RUN: %target-swift-frontend %use_no_opaque_pointers  %/s -emit-ir -gdwarf-types -o - \
+// RUN: %target-swift-frontend  %/s -emit-ir -gdwarf-types -o - \
 // RUN:   | %FileCheck %s --check-prefixes CHECK,DWARF-CHECK
-// RUN: %target-swift-frontend %/s -emit-ir -gdwarf-types -o -
 // --------------------------------------------------------------------
 // Verify that -g -debug-info-format=dwarf gives the same results as -g.
-// RUN: %target-swift-frontend %use_no_opaque_pointers %/s -emit-ir -g -debug-info-format=dwarf -o - \
+// RUN: %target-swift-frontend %/s -emit-ir -g -debug-info-format=dwarf -o - \
 // RUN:   | %FileCheck %s --check-prefixes CHECK,DWARF-CHECK
-// RUN: %target-swift-frontend %/s -emit-ir -g -debug-info-format=dwarf -o -
 // --------------------------------------------------------------------
-// RUN: %target-swift-frontend %use_no_opaque_pointers %/s -emit-ir -g -debug-info-format=codeview -o - \
+// RUN: %target-swift-frontend %/s -emit-ir -g -debug-info-format=codeview -o - \
 // RUN:   | %FileCheck %s --check-prefixes CHECK,CV-CHECK
-// RUN: %target-swift-frontend %/s -emit-ir -g -debug-info-format=codeview -o -
 // --------------------------------------------------------------------
 //
 // CHECK: foo
@@ -48,12 +44,12 @@ func foo(_ a: Int64, _ b: Int64) -> Int64 {
      var b = b
      // CHECK-DAG: ![[ALOC:.*]] = !DILocation(line: [[@LINE-3]],{{.*}} scope: ![[FOO]])
      // Check that a is the first and b is the second argument.
-     // CHECK-DAG: store i64 %0, i64* [[AADDR:.*]], align
-     // CHECK-DAG: store i64 %1, i64* [[BADDR:.*]], align
+     // CHECK-DAG: store i64 %0, ptr [[AADDR:.*]], align
+     // CHECK-DAG: store i64 %1, ptr [[BADDR:.*]], align
      // CHECK-DAG: [[AVAL:%.*]] = getelementptr inbounds {{.*}}, [[AMEM:.*]], i32 0, i32 0
      // CHECK-DAG: [[BVAL:%.*]] = getelementptr inbounds {{.*}}, [[BMEM:.*]], i32 0, i32 0
-     // CHECK-DAG: call void @llvm.dbg.declare(metadata i64* [[AADDR]], metadata ![[AARG:.*]], metadata !DIExpression()), !dbg ![[ALOC]]
-     // CHECK-DAG: call void @llvm.dbg.declare(metadata i64* [[BADDR]], metadata ![[BARG:.*]], metadata !DIExpression())
+     // CHECK-DAG: call void @llvm.dbg.declare(metadata ptr [[AADDR]], metadata ![[AARG:.*]], metadata !DIExpression()), !dbg ![[ALOC]]
+     // CHECK-DAG: call void @llvm.dbg.declare(metadata ptr [[BADDR]], metadata ![[BARG:.*]], metadata !DIExpression())
      // CHECK-DAG: ![[AARG]] = !DILocalVariable(name: "a", arg: 1
      // CHECK-DAG: ![[BARG]] = !DILocalVariable(name: "b", arg: 2
      if b != 0 {

test/DebugInfo/byref-capture.swift

@@ -1,12 +1,11 @@
-// RUN: %target-swift-frontend %use_no_opaque_pointers %s -emit-ir -g -o - | %FileCheck %s
-// RUN: %target-swift-frontend %s -emit-ir -g -o -
+// RUN: %target-swift-frontend %s -emit-ir -g -o - | %FileCheck %s
 
 func makeIncrementor(_ inc : Int64) -> () -> Int64
 {
   var sum : Int64 = 0
   // CHECK: define {{.*}}5inner
   func inner() -> Int64 {
-    // CHECK: call void @llvm.dbg.declare(metadata %Ts5Int64V**
+    // CHECK: call void @llvm.dbg.declare(metadata ptr
     // CHECK-SAME:                        metadata ![[SUM_CAPTURE:[0-9]+]],
     // CHECK-SAME:                        metadata !DIExpression(DW_OP_deref))
     // CHECK: ![[INOUTTY:[0-9]+]] = !DICompositeType({{.*}}identifier: "$ss5Int64VD"

test/DebugInfo/catch_let.swift

@@ -1,5 +1,4 @@
-// RUN: %target-swift-frontend %use_no_opaque_pointers %s -emit-ir -g -o - | %FileCheck %s
-// RUN: %target-swift-frontend %s -emit-ir -g -o -
+// RUN: %target-swift-frontend %s -emit-ir -g -o - | %FileCheck %s
 
 enum MyError : Error {
   case Yikes
@@ -17,7 +16,7 @@ public func explicitBinding() {
     try throwing()
   }
   catch let error {
-    // CHECK: call void @llvm.dbg.declare(metadata %swift.error** %{{.*}}, metadata ![[EXPLICIT_ERROR:[0-9]+]],
+    // CHECK: call void @llvm.dbg.declare(metadata ptr %{{.*}}, metadata ![[EXPLICIT_ERROR:[0-9]+]],
     use(error)
   }
 }
@@ -29,7 +28,7 @@ public func implicitBinding() {
     try throwing()
   }
   catch {
-    // CHECK: call void @llvm.dbg.declare(metadata %swift.error** %{{.*}}, metadata ![[IMPLICIT_ERROR:[0-9]+]],
+    // CHECK: call void @llvm.dbg.declare(metadata ptr %{{.*}}, metadata ![[IMPLICIT_ERROR:[0-9]+]],
     use(error)
   }
 }
@@ -41,8 +40,8 @@ public func multiBinding() {
     try throwing()
   }
   catch let error as MyError, let error as MyError {
-    // CHECK: call void @llvm.dbg.declare(metadata %swift.error** %{{.*}}, metadata ![[MULTI_BINDING_ERROR:[0-9]+]],
-    // CHECK-NOT: call void @llvm.dbg.declare(metadata %swift.error** %{{.*}}
+    // CHECK: call void @llvm.dbg.declare(metadata ptr %{{.*}}, metadata ![[MULTI_BINDING_ERROR:[0-9]+]],
+    // CHECK-NOT: call void @llvm.dbg.declare(metadata ptr %{{.*}}
     use(error)
   } catch {
     use(error)

test/DebugInfo/closure-args.swift

@@ -1,5 +1,4 @@
-// RUN: %target-swift-frontend %use_no_opaque_pointers %s -emit-ir -g -o - | %FileCheck %s
-// RUN: %target-swift-frontend %s -emit-ir -g -o -
+// RUN: %target-swift-frontend %s -emit-ir -g -o - | %FileCheck %s
 
 import Swift
 
@@ -12,20 +11,20 @@ func main() -> Void
 
     var backward_ptr  =
     // CHECK: define internal {{.*}} i1 @"$s4mainAAyyFSbSS_SStcfU_"(
-    // CHECK: %[[RANDOM_STR_ADDR:.*]] = alloca %TSS*, align {{(4|8)}}
+    // CHECK: %[[RANDOM_STR_ADDR:.*]] = alloca ptr, align {{(4|8)}}
 
     // FIXME(TODO: JIRA): i386 String is temporarily larger, and that causes the
     // value to be by-address. When that is fixed, remove the optional
     // DW_OP_deref below.
     //
-    // CHECK-NEXT: call void @llvm.dbg.declare(metadata %TSS** %[[RANDOM_STR_ADDR]], metadata !{{.*}}, metadata !DIExpression({{(DW_OP_deref)?}})), !dbg
+    // CHECK-NEXT: call void @llvm.dbg.declare(metadata ptr %[[RANDOM_STR_ADDR]], metadata !{{.*}}, metadata !DIExpression({{(DW_OP_deref)?}})), !dbg
 
-    // CHECK: store %TSS* %{{.*}}, %TSS** %[[RANDOM_STR_ADDR]], align {{(4|8)}}
+    // CHECK: store ptr %{{.*}}, ptr %[[RANDOM_STR_ADDR]], align {{(4|8)}}
     // CHECK-DAG: !DILocalVariable(name: "lhs",{{.*}} line: [[@LINE+5]],
     // CHECK-DAG: !DILocalVariable(name: "rhs",{{.*}} line: [[@LINE+4]],
-    // CHECK-DAG: !DILocalVariable(name: "random_string",{{.*}} line: 9,
-    // CHECK-DAG: !DILocalVariable(name: "random_int",{{.*}} line: 10,
-    // CHECK-DAG: !DILocalVariable(name: "out_only",{{.*}} line: 11,
+    // CHECK-DAG: !DILocalVariable(name: "random_string",{{.*}} line: 8,
+    // CHECK-DAG: !DILocalVariable(name: "random_int",{{.*}} line: 9,
+    // CHECK-DAG: !DILocalVariable(name: "out_only",{{.*}} line: 10,
         { (lhs : String, rhs : String) -> Bool in
             if rhs == random_string
                || rhs.unicodeScalars.count == random_int

test/DebugInfo/dbgvalue-insertpt.swift

@@ -1,11 +1,10 @@
-// RUN: %target-swift-frontend %use_no_opaque_pointers -g -emit-ir -Xllvm '-sil-inline-never-functions=next' %s | %FileCheck %s
-// RUN: %target-swift-frontend -g -emit-ir -Xllvm '-sil-inline-never-functions=next' %s
+// RUN: %target-swift-frontend -g -emit-ir -Xllvm '-sil-inline-never-functions=next' %s | %FileCheck %s
 
 // FIXME: This test should be testing a non-shadow-copied value instead.
 for i in 0 ..< 3 {
   // CHECK: %[[ALLOCA:[0-9]+]] = alloca %TSiSg
   // CHECK: %i.debug = alloca i{{32|64}}
-  // CHECK-NEXT: call void @llvm.dbg.declare(metadata i{{32|64}}* %i.debug,
+  // CHECK-NEXT: call void @llvm.dbg.declare(metadata ptr %i.debug,
   // CHECK-SAME:                           metadata ![[I:[0-9]+]],
   // CHECK: ![[I]] = !DILocalVariable(name: "i",
 }

test/DebugInfo/debug_info_expression.sil

@@ -1,6 +1,5 @@
 // RUN: %target-swift-frontend %s -sil-verify-all -g -emit-sil -o - | %FileCheck --check-prefix=CHECK-SIL %s
-// RUN: %target-swift-frontend %use_no_opaque_pointers -disable-debugger-shadow-copies -primary-file %s -emit-ir -g -o - | %FileCheck %s
-// RUN: %target-swift-frontend -disable-debugger-shadow-copies -primary-file %s -emit-ir -g -o -
+// RUN: %target-swift-frontend -disable-debugger-shadow-copies -primary-file %s -emit-ir -g -o - | %FileCheck %s
 import Builtin
 import Swift
 
@@ -20,9 +19,9 @@ sil hidden @test_fragment : $@convention(thin) () -> () {
 bb0:
   %2 = alloc_stack $MyStruct, var, name "my_struct", loc "file.swift":8:9, scope 1
   // CHECK: %[[MY_STRUCT:.+]] = alloca %{{.*}}MyStruct
-  // CHECK: llvm.dbg.declare(metadata {{.*}}* %[[MY_STRUCT]], metadata ![[VAR_DECL_MD:[0-9]+]]
+  // CHECK: llvm.dbg.declare(metadata {{.*}} %[[MY_STRUCT]], metadata ![[VAR_DECL_MD:[0-9]+]]
   // CHECK: %[[SMALL_STRUCT:.+]] = alloca %{{.*}}SmallStruct
-  // CHECK: llvm.dbg.declare(metadata {{.*}}* %[[SMALL_STRUCT]], metadata ![[SMALL_VAR_DECL_MD:[0-9]+]]
+  // CHECK: llvm.dbg.declare(metadata {{.*}} %[[SMALL_STRUCT]], metadata ![[SMALL_VAR_DECL_MD:[0-9]+]]
   %3 = struct_element_addr %2 : $*MyStruct, #MyStruct.x, loc "file.swift":9:17, scope 1
   // CHECK: %[[FIELD_X:.*]] = getelementptr {{.*}} %[[MY_STRUCT]]
   // CHECK-SIL: debug_value %{{[0-9]+}} : $*Builtin.Int64
@@ -50,13 +49,13 @@ sil hidden @test_alloc_stack : $@convention(thin) () -> () {
 bb0:
   %my_struct = alloc_stack $MyStruct, var, name "my_struct", loc "file.swift":15:9, scope 2
   // CHECK: %[[MY_STRUCT:.+]] = alloca %{{.*}}MyStruct
-  // CHECK: llvm.dbg.declare(metadata {{.*}}* %[[MY_STRUCT]], metadata ![[VAR_DECL_MD:[0-9]+]]
+  // CHECK: llvm.dbg.declare(metadata ptr %[[MY_STRUCT]], metadata ![[VAR_DECL_MD:[0-9]+]]
   // CHECK-SIL: alloc_stack $Int, var
   // CHECK-SIL-SAME:        (name "my_struct", loc "file.swift":15:9, scope {{[0-9]+}})
   // CHECK-SIL-SAME:        type $MyStruct, expr op_fragment:#MyStruct.x
   %field_x = alloc_stack $Int, var, (name "my_struct", loc "file.swift":15:9, scope 2), type $MyStruct, expr op_fragment:#MyStruct.x, loc "file.swift":16:17, scope 2
   // CHECK: %[[FIELD_X:.+]] = alloca %TSi
-  // CHECK: llvm.dbg.declare(metadata %TSi* %[[FIELD_X]], metadata ![[VAR_DECL_MD]]
+  // CHECK: llvm.dbg.declare(metadata ptr %[[FIELD_X]], metadata ![[VAR_DECL_MD]]
   // CHECK-SAME:             !DIExpression(DW_OP_LLVM_fragment, 0, 64)
   dealloc_stack %field_x : $*Int
   dealloc_stack %my_struct: $*MyStruct