[Mangling/ABI] NFC: Fix DebugInfo tests to reflect label mangling changes

2025-12-14 20:36:38 +01:00 · 2017-12-13 12:22:40 -08:00
parent 6519d99736
commit 600b15821d
33 changed files with 48 additions and 48 deletions
--- a/test/DebugInfo/Constructors.swift
+++ b/test/DebugInfo/Constructors.swift
@@ -1,7 +1,7 @@
 // RUN: %target-swift-frontend %s -emit-ir -g -o - | %FileCheck %s
 struct Foo {
  // Allocating constructor - should have no line table info.
-  // CHECK: !DISubprogram(name: "init", linkageName: "_T012Constructors3FooVACs5Int64V1x_tcfC",
+  // CHECK: !DISubprogram(name: "init", linkageName: "_T012Constructors3FooV1xACs5Int64V_tcfC",
  // CHECK-SAME:          line: [[@LINE+3]]
  // CHECK-NOT:           scopeLine: 0
  // CHECK-SAME:          isDefinition: true
--- a/test/DebugInfo/EagerTypeMetadata.swift
+++ b/test/DebugInfo/EagerTypeMetadata.swift
@@ -5,7 +5,7 @@ public class C<T>
  func c(_ i : T)
  {
    // Ensure that the type metadata for T is eagerly loaded at -Onone.
-    // CHECK: define {{.*}} @_T017EagerTypeMetadata1CC1cyxF
+    // CHECK: define {{.*}} @_T017EagerTypeMetadata1CC1cyyxF
    // CHECK: %T = load %swift.type*, %swift.type**
    // CHECK-SAME: !dbg ![[LOC:[0-9]+]], !invariant.load
    // CHECK: ![[LOC]] = !DILocation(line: 0,
--- a/test/DebugInfo/LinetableArtificialFn.swift
+++ b/test/DebugInfo/LinetableArtificialFn.swift
@@ -3,7 +3,7 @@
 // Verify that a helper function that is generated on-the-fly does
 // not mess up the linetable of the calling function.
 // CHECK:  store i2048 10, i2048* [[STKLOC:%.*]], align
-// CHECK:  call swiftcc {{(i32|i64)}} @_T0S2iBi2048_22_builtinIntegerLiteral_tcfC(i2048* {{.*}} [[STKLOC]]
+// CHECK:  call swiftcc {{(i32|i64)}} @_T0Si22_builtinIntegerLiteralSiBi2048__tcfC(i2048* {{.*}} [[STKLOC]]
 // CHECK: store {{(i32|i64)}} {{.*}}getelementptr
 // CHECK: store {{(i32|i64)}} {{.*}}getelementptr{{.*}}, !dbg ![[DBG:[0-9]+]]
 // CHECK-NOT: ![[DBG]] = !{i32 0, i32 0,
--- a/test/DebugInfo/archetype.swift
+++ b/test/DebugInfo/archetype.swift
@@ -22,5 +22,5 @@ func ExistentialTuple<T: RandomAccessIndex>(_ x: T, y: T) -> T.Distance {
  return _overflowChecked((tmp.0, tmp.1))
 }
 // CHECK: ![[TT]] = !DICompositeType(tag: DW_TAG_structure_type,
-// CHECK-SAME:                       name: "_T09archetype16ExistentialTuple8Distance
+// CHECK-SAME:                       name: "_T09archetype16ExistentialTuple_1y8Distance

--- a/test/DebugInfo/atype.swift
+++ b/test/DebugInfo/atype.swift
@@ -3,7 +3,7 @@
 func markUsed<T>(_ t: T) {}

 class Class {
-// CHECK: tag: DW_TAG_structure_type, name: "_T05atype5ClassC8functionyxlFQq_D"
+// CHECK: tag: DW_TAG_structure_type, name: "_T05atype5ClassC8functionyyxlFQq_D"
  func function<T>(_ x: T) {
    markUsed("hello world")
  }
--- a/test/DebugInfo/autoclosure.swift
+++ b/test/DebugInfo/autoclosure.swift
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend %s -emit-ir -g -o - | %FileCheck %s

-// CHECK: define{{.*}}@_T011autoclosure7call_meys5Int64VF
+// CHECK: define{{.*}}@_T011autoclosure7call_meyys5Int64VF
 // CHECK-NOT: ret void
 // CHECK: call void @llvm.dbg.declare{{.*}}, !dbg
 // CHECK-NOT: ret void
@@ -21,7 +21,7 @@ func &&&&&(lhs: Bool, rhs: @autoclosure () -> Bool) -> Bool {
 func call_me(_ input: Int64) -> Void {
 // rdar://problem/14627460
 // An autoclosure should have a line number in the debug info and a scope line of 0.
-// CHECK-DAG: !DISubprogram({{.*}}linkageName: "_T011autoclosure7call_meys5Int64VFSbyXKfu_",{{.*}} line: [[@LINE+3]],{{.*}} isLocal: true, isDefinition: true
+// CHECK-DAG: !DISubprogram({{.*}}linkageName: "_T011autoclosure7call_meyys5Int64VFSbyXKfu_",{{.*}} line: [[@LINE+3]],{{.*}} isLocal: true, isDefinition: true
 // But not in the line table.
 // CHECK-DAG: ![[DBG]] = !DILocation(line: [[@LINE+1]],
  if input != 0 &&&&& ( get_truth (input * 2 + 1) > 0 ) {
--- a/test/DebugInfo/basic.swift
+++ b/test/DebugInfo/basic.swift
@@ -51,7 +51,7 @@ func foo(_ a: Int64, _ b: Int64) -> Int64 {
       // CHECK-DAG: smul{{.*}}, !dbg ![[MUL:[0-9]+]]
       // CHECK-DAG: [[MUL]] = !DILocation(line: [[@LINE+4]], column: 16,
       // Runtime call to multiply function:
-       // CHECK-NOSIL: @_T0s5Int64V1moiA2B_ABtFZ{{.*}}, !dbg ![[MUL:[0-9]+]]
+       // CHECK-NOSIL: @_T0s5Int64V1moiyA2B_ABtFZ{{.*}}, !dbg ![[MUL:[0-9]+]]
       // CHECK-NOSIL: [[MUL]] = !DILocation(line: [[@LINE+1]], column: 16,
       return a*b
     } else {
--- a/test/DebugInfo/conditional-assign.swift
+++ b/test/DebugInfo/conditional-assign.swift
@@ -16,7 +16,7 @@ public class M {
  // Verify that definite initialization doesn't create a bogus description of
  // self pointing to the liveness bitvector.
  
-  // CHECK: sil @_T04main1MCAcA12WithDelegate_p4from_tKcfc
+  // CHECK: sil @_T04main1MC4fromAcA12WithDelegate_p_tKcfc
  // CHECK: bb0
  // CHECK-NEXT: %2 = alloc_stack $Builtin.Int2
  // CHECK-NOT: let
--- a/test/DebugInfo/debug_value_addr.swift
+++ b/test/DebugInfo/debug_value_addr.swift
@@ -4,10 +4,10 @@
 // Verify that -Onone shadow copies are emitted for debug_value_addr
 // instructions.

-// CHECK-SIL: sil hidden @_T016debug_value_addr4testyxlF
+// CHECK-SIL: sil hidden @_T016debug_value_addr4testyyxlF
 // CHECK-SIL: debug_value_addr %0 : $*T, let, name "t"

-// CHECK: define {{.*}}_T016debug_value_addr4testyxlF
+// CHECK: define {{.*}}_T016debug_value_addr4testyyxlF
 // CHECK: entry:
 // CHECK-NEXT: %[[TADDR:.*]] = alloca
 // CHECK-NEXT: call void @llvm.dbg.declare({{.*}}%[[TADDR]]
--- a/test/DebugInfo/dynamic_layout.swift
+++ b/test/DebugInfo/dynamic_layout.swift
@@ -8,7 +8,7 @@ class Class <T> {
  init(_x : T) {x = _x}

  // Verify that the mangling of the decl context of the type U is correct.
-  // CHECK: !DICompositeType({{.*}}name: "{{[^"]*}}_T014dynamic_layout5ClassC3foox_qd__tqd__lFQq_{{[^"]*}}"
+  // CHECK: !DICompositeType({{.*}}name: "{{[^"]*}}_T014dynamic_layout5ClassC3fooyx_qd__tqd__lFQq_{{[^"]*}}"
  func foo <U> (_ y : U) -> (T,U) {
    var tuple = (x,y)
    return tuple
--- a/test/DebugInfo/enum.swift
+++ b/test/DebugInfo/enum.swift
@@ -64,17 +64,17 @@ public func foo(_ empty : Nothing) { }
 // CHECK-SAME:             {{.*}}identifier: "_T04enum4RoseOyxG{{z?}}D")
 enum Rose<A> {
 	case MkRose(() -> A, () -> [Rose<A>])
-  // DWARF: !DICompositeType({{.*}}name: "Rose",{{.*}}identifier: "_T04enum4RoseOyAA3fooACyxGAElFQq_GD")
+  // DWARF: !DICompositeType({{.*}}name: "Rose",{{.*}}identifier: "_T04enum4RoseOyAA3fooyACyxGAElFQq_GD")
 	case IORose(() -> Rose<A>)
 }

 func foo<T>(_ x : Rose<T>) -> Rose<T> { return x }

-// CHECK: !DICompositeType({{.*}}name: "Tuple", {{.*}}elements: ![[ELTS:[0-9]+]], {{.*}}identifier: "_T04enum5TupleOyAA3barACyxGAElFQq_GD")
+// CHECK: !DICompositeType({{.*}}name: "Tuple", {{.*}}elements: ![[ELTS:[0-9]+]], {{.*}}identifier: "_T04enum5TupleOyAA3baryACyxGAElFQq_GD")
 // DWARF: !DICompositeType({{.*}}name: "Tuple", {{.*}}elements: ![[ELTS:[0-9]+]],
 // DWARF-SAME:             {{.*}}identifier: "_T04enum5TupleOyxG{{z?}}D")
 public enum Tuple<P> {
-  // DWARF: !DICompositeType({{.*}}name: "Tuple",{{.*}}identifier: "_T04enum5TupleOyAA3barACyxGAElFQq_GD")
+  // DWARF: !DICompositeType({{.*}}name: "Tuple",{{.*}}identifier: "_T04enum5TupleOyAA3baryACyxGAElFQq_GD")
 	case C(P, () -> Tuple)
 }

--- a/test/DebugInfo/generic_arg.swift
+++ b/test/DebugInfo/generic_arg.swift
@@ -1,7 +1,7 @@
 // RUN: %target-swift-frontend %s -emit-ir -g -o - | %FileCheck %s
 import StdlibUnittest
 func foo<T>(_ x: T) -> () {
-  // CHECK: define {{.*}} @_T011generic_arg3fooyxlF
+  // CHECK: define {{.*}} @_T011generic_arg3fooyyxlF
  // CHECK: %[[T:.*]] = alloca %swift.type*
  // CHECK: call void @llvm.dbg.declare(metadata %swift.type** %[[T]],
  // CHECK-SAME:               metadata ![[T1:.*]], metadata !DIExpression())
@@ -14,7 +14,7 @@ func foo<T>(_ x: T) -> () {
  // CHECK-SAME:                       flags: DIFlagArtificial)
  // CHECK: ![[X1]] = !DILocalVariable(name: "x", arg: 1,
  // CHECK-SAME:          line: 3, type: ![[TY:.*]])
-  // CHECK: ![[TY]] = !DICompositeType({{.*}}identifier: "_T011generic_arg3fooyxlFQq_D")
+  // CHECK: ![[TY]] = !DICompositeType({{.*}}identifier: "_T011generic_arg3fooyyxlFQq_D")
  _blackHole(x)
 }

--- a/test/DebugInfo/generic_arg3.swift
+++ b/test/DebugInfo/generic_arg3.swift
@@ -4,12 +4,12 @@ func apply<Type>(_ T : Type, fn: (Type) -> Type) -> Type { return fn(T) }

 public func f<Type>(_ value : Type)
 {
-  // CHECK: define {{.*}}_T012generic_arg31fyxlFxxcfU_
+  // CHECK: define {{.*}}_T012generic_arg31fyyxlFxxcfU_
  // CHECK: call void @llvm.dbg.declare(metadata %swift.opaque** %[[ALLOCA:[^,]+]],
  // CHECK-SAME:       metadata ![[ARG:.*]], metadata !DIExpression())
  // CHECK: store %swift.opaque* %1, %swift.opaque** %[[ALLOCA]], align
  // No deref here: The argument is an Archetype and this implicitly indirect.
-  // CHECK: ![[TY:.*]] = !DICompositeType({{.*}}identifier: "_T012generic_arg31fyxlFQq_D"
+  // CHECK: ![[TY:.*]] = !DICompositeType({{.*}}identifier: "_T012generic_arg31fyyxlFQq_D"
  // CHECK: ![[ARG]] = !DILocalVariable(name: "arg", arg: 1,
  // CHECK-SAME:                        line: [[@LINE+1]], type: ![[TY]])
  apply(value) { arg in return arg }
--- a/test/DebugInfo/generic_arg4.swift
+++ b/test/DebugInfo/generic_arg4.swift
@@ -3,7 +3,7 @@
 public struct Q<T> {
  let x: T
 }
-// CHECK: define {{.*}}_T012generic_arg43fooySayAA1QVyxGGlF
+// CHECK: define {{.*}}_T012generic_arg43fooyySayAA1QVyxGGlF
 // CHECK: call void @llvm.dbg.declare
 // CHECK: call void @llvm.dbg.declare(metadata %[[TY:.*]]** %[[ALLOCA:[^,]+]],
 // CHECK-SAME:       metadata ![[ARG:.*]], metadata !DIExpression())
@@ -11,6 +11,6 @@ public struct Q<T> {
 // No deref here: the array argument is passed by value.
 // CHECK: ![[ARG]] = !DILocalVariable(name: "arg", arg: 1,
 // CHECK-SAME:                        line: [[@LINE+2]], type: ![[TY:.*]])
-// CHECK: ![[TY]] = !DICompositeType({{.*}}identifier: "_T0Say12generic_arg41QVyAA3fooySayACyxGGlFQq_GGD")
+// CHECK: ![[TY]] = !DICompositeType({{.*}}identifier: "_T0Say12generic_arg41QVyAA3fooyySayACyxGGlFQq_GGD")
 public func foo<T>(_ arg: [Q<T>]) {
 }
--- a/test/DebugInfo/generic_arg5.swift
+++ b/test/DebugInfo/generic_arg5.swift
@@ -6,7 +6,7 @@ public struct S<Type>

 public func foo<Type>(_ values : [S<Type>])
 {
-  // CHECK: define {{.*}}_T012generic_arg53fooySayAA1SVyxGGlFAESgAEcfU_
+  // CHECK: define {{.*}}_T012generic_arg53fooyySayAA1SVyxGGlFAESgAEcfU_
  // CHECK: call void @llvm.dbg.declare
  // CHECK: call void @llvm.dbg.declare(metadata %[[TY:.*]]** %[[ALLOCA:[^,]+]],
  // CHECK-SAME:       metadata ![[ARG:[0-9]+]],
@@ -16,7 +16,7 @@ public func foo<Type>(_ values : [S<Type>])
  // CHECK: ![[ARG]] = !DILocalVariable(name: "arg", arg: 1,
  // CHECK-SAME:                        line: [[@LINE+3]],
  // CHECK-SAME:     type: ![[TY:.*]])
-  // CHECK: ![[TY]] = !DICompositeType({{.*}}identifier: "_T012generic_arg51SVyAA3fooySayACyxGGlFQq_GD")
+  // CHECK: ![[TY]] = !DICompositeType({{.*}}identifier: "_T012generic_arg51SVyAA3fooyySayACyxGGlFQq_GD")
  let _ = values.flatMap { arg in
    return .some(arg)
  }
--- a/test/DebugInfo/generic_args.swift
+++ b/test/DebugInfo/generic_args.swift
@@ -29,7 +29,7 @@ aFunction(AClass(),AnotherClass(),"aFunction")
 struct Wrapper<T: AProtocol> {

  init<U>(from : Wrapper<U>) {
-  // CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "Wrapper",{{.*}} identifier: "_T012generic_args7WrapperVyA2CyxGACyqd__G4from_tcAA9AProtocolRd__lufcQq_GD")
+  // CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "Wrapper",{{.*}} identifier: "_T012generic_args7WrapperVyAC4fromACyxGACyqd__G_tcAA9AProtocolRd__lufcQq_GD")
    var wrapped = from
    wrapped = from
    _ = wrapped
@@ -45,7 +45,7 @@ struct Wrapper<T: AProtocol> {
  }
 }

-// CHECK-DAG: ![[FNTY:.*]] = !DICompositeType({{.*}}identifier: "_T012generic_args5applyq_x_q_xc1ftr0_lFQq_AaBq_x_q_xcACtr0_lFQq0_Igir_D"
+// CHECK-DAG: ![[FNTY:.*]] = !DICompositeType({{.*}}identifier: "_T012generic_args5apply_1fq_x_q_xctr0_lFQq_AaB_ACq_x_q_xctr0_lFQq0_Igir_D"
 // CHECK-DAG: !DILocalVariable(name: "f", {{.*}}, line: [[@LINE+1]], type: ![[FNTY]])
 func apply<T, U> (_ x: T, f: (T) -> (U)) -> U {
  return f(x)
--- a/test/DebugInfo/generic_enum_closure.swift
+++ b/test/DebugInfo/generic_enum_closure.swift
@@ -5,7 +5,7 @@ struct CErrorOr<T>
 {
  var value : T?
  init(x : __CurrentErrno) {
-    // CHECK: define hidden {{.*}}void @_T020generic_enum_closure8CErrorOrVACyxGAA14__CurrentErrnoV1x_tcfC
+    // CHECK: define hidden {{.*}}void @_T020generic_enum_closure8CErrorOrV1xACyxGAA14__CurrentErrnoV_tcfC
    // CHECK-NOT: define
    // This is a SIL-level debug_value_addr instruction.
    // CHECK: call void @llvm.dbg.value({{.*}}, metadata ![[SELF:.*]], metadata !DIExpression())
--- a/test/DebugInfo/guard-let.swift
+++ b/test/DebugInfo/guard-let.swift
@@ -7,7 +7,7 @@ func use<T>(_ t: T) {}

 public func f(_ i : Int?)
 {
-  // CHECK: define {{.*}}@_T04main1fySiSgF
+  // CHECK: define {{.*}}@_T04main1fyySiSgF
  // The shadow copy store should not have a location.
  // Note that the store must be in the same scope or else it might defeat
  // livedebugvalues.
@@ -28,7 +28,7 @@ public func f(_ i : Int?)

 public func g(_ s : String?)
 {
-  // CHECK2: define {{.*}}@_T04main1gySSSgF
+  // CHECK2: define {{.*}}@_T04main1gyySSSgF
  // The shadow copy store should not have a location.
  // CHECK2: getelementptr inbounds {{.*}} %s.debug, {{.*}}, !dbg ![[DBG0:.*]]
  // CHECK2: ![[G:.*]] = distinct !DISubprogram(name: "g"
--- a/test/DebugInfo/inlined-generics.swift
+++ b/test/DebugInfo/inlined-generics.swift
@@ -10,7 +10,7 @@ func foo1<T:P>(_ t: T, _ dt: T.DT1) -> T.DT1 {
  return dttmp
 }

-// CHECK: define {{.*}}@_T04main4foo2yxAA1PRzlF
+// CHECK: define {{.*}}@_T04main4foo2yyxAA1PRzlF
 public func foo2<S:P>(_ s: S) {
  // CHECK: call void @llvm.dbg.value(metadata %swift.type* %S.DT1,
  // CHECK-SAME:                     metadata ![[META:[0-9]+]]
--- a/test/DebugInfo/inlinedAt.swift
+++ b/test/DebugInfo/inlinedAt.swift
@@ -24,14 +24,14 @@ public func f(_ i : Int) -> Int { // 301
  return g(i)                     // 302
 }

-// CHECK-SIL: sil {{.*}}@_T09inlinedAt1fS2iF :
+// CHECK-SIL: sil {{.*}}@_T09inlinedAt1fyS2iF :
 // CHECK-SIL-NOT: return
 // CHECK-SIL: debug_value %0 : $Int, let, name "k", argno 1
 // CHECK-SIL-SAME: line:101:10:in_prologue
 // CHECK-SIL-SAME: perf_inlined_at line:203:10
 // CHECK-SIL-SAME: perf_inlined_at line:302:10

-// CHECK: define {{.*}}@_T09inlinedAt1fS2iF({{.*}})
+// CHECK: define {{.*}}@_T09inlinedAt1fyS2iF({{.*}})
 // CHECK-NOT: ret
 // CHECK: @llvm.dbg.value
 // CHECK: @llvm.dbg.value
--- a/test/DebugInfo/inlinescopes.swift
+++ b/test/DebugInfo/inlinescopes.swift
@@ -33,4 +33,4 @@ let y = inlined(x)
 use(y)

 // Check if the inlined and removed function still has the correct linkage name.
-// CHECK-DAG: !DISubprogram(name: "inlined", linkageName: "_T04main7inlineds5Int64VADF"
+// CHECK-DAG: !DISubprogram(name: "inlined", linkageName: "_T04main7inlinedys5Int64VADF"
--- a/test/DebugInfo/inout.swift
+++ b/test/DebugInfo/inout.swift
@@ -14,7 +14,7 @@ typealias MyFloat = Float
 // CHECK-SAME:                        %[[ALLOCA]], metadata ![[A:[0-9]+]]

 // Closure with promoted capture.
-// PROMO-CHECK: define {{.*}}@_T05inout13modifyFooHeapys5Int64Vz_SftFADycfU_
+// PROMO-CHECK: define {{.*}}@_T05inout13modifyFooHeapyys5Int64Vz_SftFADycfU_
 // PROMO-CHECK: call void @llvm.dbg.declare(metadata %Ts5Int64V** %
 // PROMO-CHECK-SAME:   metadata ![[A1:[0-9]+]], metadata !DIExpression())

@@ -37,7 +37,7 @@ func modifyFooHeap(_ a: inout Int64,
 }

 // Inout reference type.
-// FOO-CHECK: define {{.*}}@_T05inout9modifyFooys5Int64Vz_SftF
+// FOO-CHECK: define {{.*}}@_T05inout9modifyFooyys5Int64Vz_SftF
 // FOO-CHECK: call void @llvm.dbg.declare(metadata %Ts5Int64V** %
 // FOO-CHECK-SAME:          metadata ![[U:[0-9]+]], metadata !DIExpression())
 func modifyFoo(_ u: inout Int64,
--- a/test/DebugInfo/iuo_arg.swift
+++ b/test/DebugInfo/iuo_arg.swift
@@ -13,7 +13,7 @@ class CIFilter {
 }

 class MyClass {
-  // CHECK: define hidden {{.*}} %T7iuo_arg7UIImageC* @_T07iuo_arg7MyClassC11filterImageAA7UIImageCSQyAFG_SbtF
+  // CHECK: define hidden {{.*}} %T7iuo_arg7UIImageC* @_T07iuo_arg7MyClassC11filterImageyAA7UIImageCSQyAFG_SbtF
  func filterImage(_ image: UIImage!, _ doSomething:Bool) -> UIImage
 	{
    // Test that image is in an alloca, but not an indirect location.
--- a/test/DebugInfo/linetable-assign.swift
+++ b/test/DebugInfo/linetable-assign.swift
@@ -3,7 +3,7 @@
 // RUN:   | %FileCheck %s
 public func g<T>(_ t: T) {}
 public func f(_ i: Int32) {
-  // CHECK: function_ref @_T04main1fys5Int32VFyycfU_
+  // CHECK: function_ref @_T04main1fyys5Int32VFyycfU_
  // CHECK-SAME: loc "{{.*}}":13:3,
  // CHECK: %[[CLOSURE:.*]] = partial_apply
  // CHECK-SAME: loc "{{.*}}":13:3,{{.*}}auto_gen
--- a/test/DebugInfo/linetable-cleanups.swift
+++ b/test/DebugInfo/linetable-cleanups.swift
@@ -17,11 +17,11 @@ func main() {
        markUsed("element = \(element)")
    }
    markUsed("Done with the for loop")
-// CHECK: call {{.*}}void @_T04main8markUsedyxlF
+// CHECK: call {{.*}}void @_T04main8markUsedyyxlF
 // CHECK: br label
 // CHECK: <label>:
 // CHECK: call %Ts16IndexingIteratorVySaySiGG* @_T0s16IndexingIteratorVySaySiGGWh0_(%Ts16IndexingIteratorVySaySiGG* %{{.*}}), !dbg ![[LOOPHEADER_LOC:.*]]
-// CHECK: call {{.*}}void @_T04main8markUsedyxlF
+// CHECK: call {{.*}}void @_T04main8markUsedyyxlF
 // The cleanups should share the line number with the ret stmt.
 // CHECK:  call %TSa* @_T0SaySiGWh0_(%TSa* %{{.*}}), !dbg ![[CLEANUPS:.*]]
 // CHECK-NEXT:  !dbg ![[CLEANUPS]]
--- a/test/DebugInfo/linetable.swift
+++ b/test/DebugInfo/linetable.swift
@@ -29,7 +29,7 @@ func main(_ x: Int64) -> Void
 // ASM-CHECK: .loc [[FILEID:[0-9]]] [[@LINE+1]] 5
    call_me (
 // ASM-CHECK-NOT: .loc [[FILEID]] [[@LINE+1]] 5
-// CHECK-LABEL: define {{.*}} @_T09linetable4mainys5Int64VFyycfU_Tf2in_n({{.*}})
+// CHECK-LABEL: define {{.*}} @_T09linetable4mainyys5Int64VFyycfU_Tf2in_n({{.*}})
        {
            var result = my_class.do_something(x)
            markUsed(result)
@@ -49,7 +49,7 @@ func main(_ x: Int64) -> Void
 // ASM-CHECK: ret
 }

-// ASM-CHECK: {{^_?_T09linetable4mainys5Int64VFyycfU_Tf2in_n:}}
+// ASM-CHECK: {{^_?_T09linetable4mainyys5Int64VFyycfU_Tf2in_n:}}
 // ASM-CHECK-NOT: retq
 // The end-of-prologue should have a valid location (0 is ok, too).
 // ASM-CHECK: .loc [[FILEID]] {{0|34}} {{[0-9]+}} prologue_end
--- a/test/DebugInfo/patternvars.swift
+++ b/test/DebugInfo/patternvars.swift
@@ -33,7 +33,7 @@ public func mangle(s: [UnicodeScalar]) -> [UnicodeScalar] {
 // which shares the storage with the expression in the switch statement. Make
 // sure we emit a dbg.value once per basic block.

-// CHECK: define {{.*}}@_T011patternvars6mangleSayAA13UnicodeScalarVGAE1s_tFA2DcfU_
+// CHECK: define {{.*}}@_T011patternvars6mangle1sSayAA13UnicodeScalarVGAF_tFA2EcfU_
 // CHECK: %[[VAL:[0-9]+]] = call swiftcc i32 @_T011patternvars13UnicodeScalarV5values6UInt32Vvg(i32 %0)
 // CHECK-NEXT:  call void @llvm.dbg.value(metadata i32 %[[VAL]]
 // CHECK:       ; <label>
--- a/test/DebugInfo/prologue.swift
+++ b/test/DebugInfo/prologue.swift
@@ -6,7 +6,7 @@ func markUsed<T>(_ t: T) {}

 // CHECK: .file [[F:[0-9]+]] "{{.*}}prologue.swift"
 func bar<T, U>(_ x: T, y: U) { markUsed("bar") }
-// CHECK: _T08prologue3baryx_q_1ytr0_lF:
+// CHECK: __T08prologue3bar_1yyx_q_tr0_lF:
 // CHECK: .loc	[[F]] 0 0 prologue_end
 // Make sure there is no allocation happening between the end of
 // prologue and the beginning of the function body.
--- a/test/DebugInfo/protocolarg.swift
+++ b/test/DebugInfo/protocolarg.swift
@@ -7,7 +7,7 @@ public protocol IGiveOutInts {
  func callMe() -> Int64
 }

-// CHECK: define {{.*}}@_T011protocolarg16printSomeNumbersyAA12IGiveOutInts_pF
+// CHECK: define {{.*}}@_T011protocolarg16printSomeNumbersyyAA12IGiveOutInts_pF
 // CHECK: @llvm.dbg.declare(metadata %T11protocolarg12IGiveOutIntsP** %
 // CHECK-SAME:              metadata ![[ARG:[0-9]+]],
 // CHECK-SAME:              metadata !DIExpression(DW_OP_deref))
--- a/test/DebugInfo/return.swift
+++ b/test/DebugInfo/return.swift
@@ -10,7 +10,7 @@ public func ifelseexpr() -> Int64 {
  var x = X(i:0)
  // CHECK: [[ALLOCA:%.*]] = alloca %T6return1XC*
  // CHECK: [[META:%.*]] = call %swift.type* @_T06return1XCMa()
-  // CHECK: [[X:%.*]] = call {{.*}}%T6return1XC* @_T06return1XCACs5Int64V1i_tcfC(
+  // CHECK: [[X:%.*]] = call {{.*}}%T6return1XC* @_T06return1XC1iACs5Int64V_tcfC(
  // CHECK-SAME:                                  i64 0, %swift.type* swiftself [[META]])
  // CHECK:  store %T6return1XC* [[X]], %T6return1XC** [[ALLOCA]]
  // CHECK:  @swift_rt_swift_release to void (%T6return1XC*)*)(%T6return1XC* [[X]])
--- a/test/DebugInfo/shadow_copies.swift
+++ b/test/DebugInfo/shadow_copies.swift
@@ -16,7 +16,7 @@ class ClassB : ClassA
 {
    override init (_ input : Int64)
    {
-    // CHECK: @_T0{{.*}}6ClassBCACs5Int64Vcfc
+    // CHECK: @_T0{{.*}}6ClassBCyACs5Int64Vcfc
    // CHECK:  alloca {{.*}}ClassBC*
    // CHECK:  alloca i64
    // CHECK-NOT: alloca
--- a/test/DebugInfo/specialization.swift
+++ b/test/DebugInfo/specialization.swift
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -O %s -disable-llvm-optzns -emit-sil -g -o - | %FileCheck %s

-// CHECK: sil shared [noinline] @_T014specialization3sumxx_xtAA5ProtoRzlFAA7AddableV_Tg5
+// CHECK: sil shared [noinline] @_T014specialization3sumyxx_xtAA5ProtoRzlFAA7AddableV_Tg5
 // CHECK-SAME: $@convention(thin) (Addable, Addable) -> Addable {
 // CHECK: bb0(%0 : $Addable, %1 : $Addable):
 // CHECK:  debug_value %0 : $Addable, let, name "i", argno 1
--- a/test/DebugInfo/test-foundation.swift
+++ b/test/DebugInfo/test-foundation.swift
@@ -53,10 +53,10 @@ public func err() {

 // LOC-CHECK: define {{.*}}4date
 public func date() {
-  // LOC-CHECK: call {{.*}} @_T0S2SBp21_builtinStringLiteral_Bw17utf8CodeUnitCountBi1_7isASCIItcfC{{.*}}, !dbg ![[L1:.*]]
+  // LOC-CHECK: call {{.*}} @_T0SS21_builtinStringLiteral17utf8CodeUnitCount7isASCIISSBp_BwBi1_tcfC{{.*}}, !dbg ![[L1:.*]]
  let d1 = DateFormatter()
  d1.dateFormat = "dd. mm. yyyy" // LOC-CHECK: call{{.*}}objc_msgSend{{.*}}, !dbg ![[L2:.*]]
-  // LOC-CHECK: call {{.*}} @_T0S2SBp21_builtinStringLiteral_Bw17utf8CodeUnitCountBi1_7isASCIItcfC{{.*}}, !dbg ![[L3:.*]]
+  // LOC-CHECK: call {{.*}} @_T0SS21_builtinStringLiteral17utf8CodeUnitCount7isASCIISSBp_BwBi1_tcfC{{.*}}, !dbg ![[L3:.*]]
  let d2 = DateFormatter()
  d2.dateFormat = "mm dd yyyy" // LOC-CHECK: call{{.*}}objc_msgSend{{.*}}, !dbg ![[L4:.*]]
 }