From 6334e264fb52bd4a2ca9dfeb4115c648eaaecdc7 Mon Sep 17 00:00:00 2001
From: Shoaib Meenai <smeenai@fb.com>
Date: Mon, 9 Sep 2024 12:57:44 -0700
Subject: [PATCH] [CIR][Dialect] Remove 22 prefix and suffix from type aliases

We were previously printing the type alias for `struct S` as `!ty_22S22`
instead of just `!ty_S`. This was because our alias computation for a
StructType did the following:

    os << "ty_" << structType.getName()

`structType.getName()` is a `StringAttr`, and writing a `StringAttr` to
an output stream adds double quotes around the actual string [1][2].
These double quotes then get hex-encoded as 22 [3].

We can fix this by writing the actual string value instead. Aliases that
would end in a number will now receive a trailing underscore because of
MLIR's alias sanitization not allowing a trailing digit [4] (which
ironically didn't kick in even though our aliases were always previously
ending with a number, which might be a bug in the sanitization logic).
Aliases containing other special characters (e.g. `::`) will still be
escaped as before. In other words:

```
struct S {};
// before: !ty_22S22 = ...
// after:  !ty_S = ...

struct S1 {};
// before: !ty_22S122 = ...
// after:  !ty_S1_ = ...

struct std::string {};
// before: !ty_22std3A3Astring22
// after:  !ty_std3A3Astring
```

I'm not a big fan of the trailing underscore special-case, but I also
don't want to touch core MLIR logic, and I think the end result is still
nicer than before.

The tests were mechanically updated with the following command run
inside `clang/test/CIR`, and the same commands can be run to update the
tests for any in-flight patches. (These are for GNU sed; for macOS
change the `-i` to `-i ''`.)

    find . -type f | xargs sed -i -E -e 's/ty_22([A-Za-z0-9_$]+[0-9])22/ty_\1_/g' -e 's/ty_22([A-Za-z0-9_$]+)22/ty_\1/g'

clang/test/CIR/CodeGen/stmtexpr-init.c needed an additional minor fix to
swap the expected order of two type aliases in the CIR output.
clang/test/CIR/CodeGen/coro-task.cpp needed some surgery because it was
searching for `22` to find the end of a type alias; I changed it to
search for the actual alias instead.

[1] https://github.com/llvm/llvm-project/blob/b3d2d5039b9b8aa10a86c593387f200b15c02aef/mlir/lib/IR/AsmPrinter.cpp#L2295
[2] https://github.com/llvm/llvm-project/blob/b3d2d5039b9b8aa10a86c593387f200b15c02aef/mlir/lib/IR/AsmPrinter.cpp#L2763
[3] https://github.com/llvm/llvm-project/blob/b3d2d5039b9b8aa10a86c593387f200b15c02aef/mlir/lib/IR/AsmPrinter.cpp#L1014
[4] https://github.com/llvm/llvm-project/blob/b3d2d5039b9b8aa10a86c593387f200b15c02aef/mlir/lib/IR/AsmPrinter.cpp#L1154
---
 clang/lib/CIR/Dialect/IR/CIRDialect.cpp       |  8 +-
 clang/test/CIR/CodeGen/String.cpp             | 30 +++---
 clang/test/CIR/CodeGen/abstract-cond.c        | 12 +--
 clang/test/CIR/CodeGen/agg-copy.c             | 78 ++++++++--------
 clang/test/CIR/CodeGen/agg-init.cpp           | 24 ++---
 clang/test/CIR/CodeGen/agg-init2.cpp          |  8 +-
 clang/test/CIR/CodeGen/array-init-destroy.cpp | 38 ++++----
 clang/test/CIR/CodeGen/array-init.c           | 18 ++--
 clang/test/CIR/CodeGen/array.c                |  2 +-
 clang/test/CIR/CodeGen/array.cpp              |  2 +-
 clang/test/CIR/CodeGen/asm.c                  |  2 +-
 clang/test/CIR/CodeGen/assign-operator.cpp    | 48 +++++-----
 clang/test/CIR/CodeGen/atomic.cpp             |  4 +-
 clang/test/CIR/CodeGen/bitfield-union.c       | 10 +-
 clang/test/CIR/CodeGen/bitfields.c            | 32 +++----
 clang/test/CIR/CodeGen/bitfields.cpp          | 20 ++--
 clang/test/CIR/CodeGen/bool.c                 | 22 ++---
 clang/test/CIR/CodeGen/build-deferred.cpp     |  2 +-
 clang/test/CIR/CodeGen/builtin-bit-cast.cpp   | 16 ++--
 .../CodeGen/call-via-class-member-funcptr.cpp |  8 +-
 clang/test/CIR/CodeGen/cast.c                 |  8 +-
 clang/test/CIR/CodeGen/cast.cpp               |  8 +-
 clang/test/CIR/CodeGen/compound-literal.c     | 22 ++---
 clang/test/CIR/CodeGen/cond.cpp               |  6 +-
 clang/test/CIR/CodeGen/const-bitfields.c      | 10 +-
 clang/test/CIR/CodeGen/coro-task.cpp          | 52 +++++------
 clang/test/CIR/CodeGen/ctor-alias.cpp         | 20 ++--
 .../CodeGen/ctor-member-lvalue-to-rvalue.cpp  | 12 +--
 clang/test/CIR/CodeGen/ctor.cpp               | 24 ++---
 clang/test/CIR/CodeGen/delegating-ctor.cpp    | 24 ++---
 clang/test/CIR/CodeGen/derived-to-base.cpp    | 74 +++++++--------
 clang/test/CIR/CodeGen/dtors-scopes.cpp       |  8 +-
 clang/test/CIR/CodeGen/dtors.cpp              |  8 +-
 clang/test/CIR/CodeGen/dynamic-cast-exact.cpp | 30 +++---
 .../CodeGen/dynamic-cast-relative-layout.cpp  | 12 +--
 clang/test/CIR/CodeGen/dynamic-cast.cpp       | 38 ++++----
 clang/test/CIR/CodeGen/evaluate-expr.c        |  2 +-
 clang/test/CIR/CodeGen/fun-ptr.c              | 24 ++---
 .../CIR/CodeGen/globals-neg-index-array.c     |  2 +-
 clang/test/CIR/CodeGen/globals.c              |  8 +-
 clang/test/CIR/CodeGen/lambda.cpp             | 46 +++++-----
 clang/test/CIR/CodeGen/libcall.cpp            |  2 +-
 clang/test/CIR/CodeGen/lvalue-refs.cpp        |  8 +-
 clang/test/CIR/CodeGen/multi-vtable.cpp       | 22 ++---
 clang/test/CIR/CodeGen/new.cpp                | 28 +++---
 clang/test/CIR/CodeGen/packed-structs.c       | 12 +--
 .../CIR/CodeGen/pointer-to-data-member.cpp    | 22 ++---
 .../CIR/CodeGen/pointer-to-member-func.cpp    | 14 +--
 clang/test/CIR/CodeGen/rangefor.cpp           | 24 ++---
 .../skip-functions-from-system-headers.cpp    |  2 +-
 clang/test/CIR/CodeGen/static.cpp             | 56 +++++------
 clang/test/CIR/CodeGen/stmt-expr.c            |  8 +-
 clang/test/CIR/CodeGen/stmt-expr.cpp          | 10 +-
 clang/test/CIR/CodeGen/stmtexpr-init.c        |  2 +-
 clang/test/CIR/CodeGen/struct.c               | 38 ++++----
 clang/test/CIR/CodeGen/struct.cpp             | 92 +++++++++----------
 clang/test/CIR/CodeGen/structural-binding.cpp | 36 ++++----
 .../test/CIR/CodeGen/three-way-comparison.cpp |  4 +-
 clang/test/CIR/CodeGen/typedef.c              |  2 +-
 clang/test/CIR/CodeGen/union-init.c           |  8 +-
 clang/test/CIR/CodeGen/union.cpp              | 46 +++++-----
 clang/test/CIR/CodeGen/var-arg-float.c        | 20 ++--
 clang/test/CIR/CodeGen/var-arg-scope.c        | 20 ++--
 clang/test/CIR/CodeGen/var-arg.c              | 20 ++--
 clang/test/CIR/CodeGen/vector.cpp             |  8 +-
 clang/test/CIR/CodeGen/vtable-rtti.cpp        |  2 +-
 clang/test/CIR/IR/data-member-ptr.cir         | 18 ++--
 clang/test/CIR/IR/getmember.cir               | 18 ++--
 clang/test/CIR/IR/global.cir                  | 22 ++---
 clang/test/CIR/IR/invalid.cir                 | 14 +--
 clang/test/CIR/IR/struct.cir                  | 20 ++--
 .../test/CIR/Lowering/ThroughMLIR/vtable.cir  | 26 +++---
 clang/test/CIR/Lowering/array.cir             |  4 +-
 clang/test/CIR/Lowering/class.cir             | 34 +++----
 clang/test/CIR/Lowering/const.cir             |  8 +-
 clang/test/CIR/Lowering/globals.cir           | 28 +++---
 clang/test/CIR/Lowering/struct.cir            | 34 +++----
 clang/test/CIR/Lowering/unions.cir            | 18 ++--
 clang/test/CIR/Lowering/variadics.cir         | 20 ++--
 .../x86_64/x86_64-call-conv-lowering-pass.cpp | 14 +--
 80 files changed, 803 insertions(+), 803 deletions(-)

diff --git a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
index 3db1e988b2d1..3d8fd4666750 100644
--- a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
+++ b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
@@ -59,11 +59,11 @@ struct CIROpAsmDialectInterface : public OpAsmDialectInterface {
 
   AliasResult getAlias(Type type, raw_ostream &os) const final {
     if (auto structType = dyn_cast<StructType>(type)) {
-      if (!structType.getName()) {
+      StringAttr nameAttr = structType.getName();
+      if (!nameAttr)
         os << "ty_anon_" << structType.getKindAsStr();
-        return AliasResult::OverridableAlias;
-      }
-      os << "ty_" << structType.getName();
+      else
+        os << "ty_" << nameAttr.getValue();
       return AliasResult::OverridableAlias;
     }
     if (auto intType = dyn_cast<IntType>(type)) {
diff --git a/clang/test/CIR/CodeGen/String.cpp b/clang/test/CIR/CodeGen/String.cpp
index c504c1d99d0c..5898eb09fbb6 100644
--- a/clang/test/CIR/CodeGen/String.cpp
+++ b/clang/test/CIR/CodeGen/String.cpp
@@ -18,20 +18,20 @@ void test() {
 }
 
 //      CHECK: cir.func linkonce_odr @_ZN6StringC2Ev
-// CHECK-NEXT:   %0 = cir.alloca !cir.ptr<!ty_22String22>
+// CHECK-NEXT:   %0 = cir.alloca !cir.ptr<!ty_String>
 // CHECK-NEXT:   cir.store %arg0, %0
 // CHECK-NEXT:   %1 = cir.load %0
 // CHECK-NEXT:   %2 = cir.get_member %1[0] {name = "storage"}
 // CHECK-NEXT:   %3 = cir.const #cir.ptr<null> : !cir.ptr<!s8i>
 // CHECK-NEXT:   cir.store %3, %2 : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
-// CHECK-NEXT:   %4 = cir.get_member %1[1] {name = "size"} : !cir.ptr<!ty_22String22> -> !cir.ptr<!s64i>
+// CHECK-NEXT:   %4 = cir.get_member %1[1] {name = "size"} : !cir.ptr<!ty_String> -> !cir.ptr<!s64i>
 // CHECK-NEXT:   %5 = cir.const #cir.int<0> : !s32i
 // CHECK-NEXT:   %6 = cir.cast(integral, %5 : !s32i), !s64i
 // CHECK-NEXT:   cir.store %6, %4 : !s64i, !cir.ptr<!s64i>
 // CHECK-NEXT:   cir.return
 // CHECK-NEXT: }
 //      CHECK: cir.func linkonce_odr @_ZN6StringC2Ei
-// CHECK-NEXT:   %0 = cir.alloca !cir.ptr<!ty_22String22>
+// CHECK-NEXT:   %0 = cir.alloca !cir.ptr<!ty_String>
 // CHECK-NEXT:   %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["size", init]
 // CHECK-NEXT:   cir.store %arg0, %0
 // CHECK-NEXT:   cir.store %arg1, %1
@@ -39,7 +39,7 @@ void test() {
 // CHECK-NEXT:   %3 = cir.get_member %2[0] {name = "storage"}
 // CHECK-NEXT:   %4 = cir.const #cir.ptr<null> : !cir.ptr<!s8i>
 // CHECK-NEXT:   cir.store %4, %3
-// CHECK-NEXT:   %5 = cir.get_member %2[1] {name = "size"} : !cir.ptr<!ty_22String22> -> !cir.ptr<!s64i>
+// CHECK-NEXT:   %5 = cir.get_member %2[1] {name = "size"} : !cir.ptr<!ty_String> -> !cir.ptr<!s64i>
 // CHECK-NEXT:   %6 = cir.load %1 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:   %7 = cir.cast(integral, %6 : !s32i), !s64i
 // CHECK-NEXT:   cir.store %7, %5 : !s64i, !cir.ptr<!s64i>
@@ -47,27 +47,27 @@ void test() {
 // CHECK-NEXT: }
 
 //      CHECK: cir.func linkonce_odr @_ZN6StringC2EPKc
-// CHECK-NEXT:   %0 = cir.alloca !cir.ptr<!ty_22String22>, !cir.ptr<!cir.ptr<!ty_22String22>>, ["this", init] {alignment = 8 : i64}
+// CHECK-NEXT:   %0 = cir.alloca !cir.ptr<!ty_String>, !cir.ptr<!cir.ptr<!ty_String>>, ["this", init] {alignment = 8 : i64}
 // CHECK-NEXT:   %1 = cir.alloca !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>, ["s", init] {alignment = 8 : i64}
-// CHECK-NEXT:   cir.store %arg0, %0 : !cir.ptr<!ty_22String22>, !cir.ptr<!cir.ptr<!ty_22String22>>
+// CHECK-NEXT:   cir.store %arg0, %0 : !cir.ptr<!ty_String>, !cir.ptr<!cir.ptr<!ty_String>>
 // CHECK-NEXT:   cir.store %arg1, %1 : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
-// CHECK-NEXT:   %2 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22String22>>, !cir.ptr<!ty_22String22>
-// CHECK-NEXT:   %3 = cir.get_member %2[0] {name = "storage"} : !cir.ptr<!ty_22String22> -> !cir.ptr<!cir.ptr<!s8i>>
+// CHECK-NEXT:   %2 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_String>>, !cir.ptr<!ty_String>
+// CHECK-NEXT:   %3 = cir.get_member %2[0] {name = "storage"} : !cir.ptr<!ty_String> -> !cir.ptr<!cir.ptr<!s8i>>
 // CHECK-NEXT:   %4 = cir.const #cir.ptr<null> : !cir.ptr<!s8i>
 // CHECK-NEXT:   cir.store %4, %3 : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
 // CHECK-NEXT:   cir.return
 
 //      CHECK: cir.func linkonce_odr @_ZN6StringC1EPKc
-// CHECK-NEXT:   %0 = cir.alloca !cir.ptr<!ty_22String22>, !cir.ptr<!cir.ptr<!ty_22String22>>, ["this", init] {alignment = 8 : i64}
+// CHECK-NEXT:   %0 = cir.alloca !cir.ptr<!ty_String>, !cir.ptr<!cir.ptr<!ty_String>>, ["this", init] {alignment = 8 : i64}
 // CHECK-NEXT:   %1 = cir.alloca !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>, ["s", init] {alignment = 8 : i64}
-// CHECK-NEXT:   cir.store %arg0, %0 : !cir.ptr<!ty_22String22>, !cir.ptr<!cir.ptr<!ty_22String22>>
+// CHECK-NEXT:   cir.store %arg0, %0 : !cir.ptr<!ty_String>, !cir.ptr<!cir.ptr<!ty_String>>
 // CHECK-NEXT:   cir.store %arg1, %1 : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
-// CHECK-NEXT:   %2 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22String22>>, !cir.ptr<!ty_22String22>
+// CHECK-NEXT:   %2 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_String>>, !cir.ptr<!ty_String>
 // CHECK-NEXT:   %3 = cir.load %1 : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
-// CHECK-NEXT:   cir.call @_ZN6StringC2EPKc(%2, %3) : (!cir.ptr<!ty_22String22>, !cir.ptr<!s8i>) -> ()
+// CHECK-NEXT:   cir.call @_ZN6StringC2EPKc(%2, %3) : (!cir.ptr<!ty_String>, !cir.ptr<!s8i>) -> ()
 // CHECK-NEXT:   cir.return
 
 // CHECK: cir.func @_Z4testv()
-// CHECK:   cir.call @_ZN6StringC1Ev(%0) : (!cir.ptr<!ty_22String22>) -> ()
-// CHECK:   cir.call @_ZN6StringC1Ei(%1, %3) : (!cir.ptr<!ty_22String22>, !s32i) -> ()
-// CHECK:   cir.call @_ZN6StringC1EPKc(%2, %5) : (!cir.ptr<!ty_22String22>, !cir.ptr<!s8i>) -> ()
+// CHECK:   cir.call @_ZN6StringC1Ev(%0) : (!cir.ptr<!ty_String>) -> ()
+// CHECK:   cir.call @_ZN6StringC1Ei(%1, %3) : (!cir.ptr<!ty_String>, !s32i) -> ()
+// CHECK:   cir.call @_ZN6StringC1EPKc(%2, %5) : (!cir.ptr<!ty_String>, !cir.ptr<!s8i>) -> ()
diff --git a/clang/test/CIR/CodeGen/abstract-cond.c b/clang/test/CIR/CodeGen/abstract-cond.c
index 426adf7337a6..d724c8e1ea28 100644
--- a/clang/test/CIR/CodeGen/abstract-cond.c
+++ b/clang/test/CIR/CodeGen/abstract-cond.c
@@ -11,17 +11,17 @@ int f6(int a0, struct s6 a1, struct s6 a2) {
 
 // CIR-LABEL: @f6
 // CIR:  %[[A0:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a0"
-// CIR:  %[[A1:.*]] = cir.alloca !ty_22s622, !cir.ptr<!ty_22s622>, ["a1"
-// CIR:  %[[A2:.*]] = cir.alloca !ty_22s622, !cir.ptr<!ty_22s622>, ["a2"
-// CIR:  %[[TMP:.*]] = cir.alloca !ty_22s622, !cir.ptr<!ty_22s622>, ["tmp"] {alignment = 4 : i64}
+// CIR:  %[[A1:.*]] = cir.alloca !ty_s6_, !cir.ptr<!ty_s6_>, ["a1"
+// CIR:  %[[A2:.*]] = cir.alloca !ty_s6_, !cir.ptr<!ty_s6_>, ["a2"
+// CIR:  %[[TMP:.*]] = cir.alloca !ty_s6_, !cir.ptr<!ty_s6_>, ["tmp"] {alignment = 4 : i64}
 // CIR:  %[[LOAD_A0:.*]] = cir.load %[[A0]] : !cir.ptr<!s32i>, !s32i
 // CIR:  %[[COND:.*]] = cir.cast(int_to_bool, %[[LOAD_A0]] : !s32i), !cir.bool
 // CIR:  cir.if %[[COND]] {
-// CIR:    cir.copy %[[A1]] to %[[TMP]] : !cir.ptr<!ty_22s622>
+// CIR:    cir.copy %[[A1]] to %[[TMP]] : !cir.ptr<!ty_s6_>
 // CIR:  } else {
-// CIR:    cir.copy %[[A2]] to %[[TMP]] : !cir.ptr<!ty_22s622>
+// CIR:    cir.copy %[[A2]] to %[[TMP]] : !cir.ptr<!ty_s6_>
 // CIR:  }
-// CIR:  cir.get_member %[[TMP]][0] {name = "f0"} : !cir.ptr<!ty_22s622> -> !cir.ptr<!s32i>
+// CIR:  cir.get_member %[[TMP]][0] {name = "f0"} : !cir.ptr<!ty_s6_> -> !cir.ptr<!s32i>
 
 // LLVM-LABEL: @f6
 // LLVM:    %[[LOAD_A0:.*]] = load i32, ptr {{.*}}
diff --git a/clang/test/CIR/CodeGen/agg-copy.c b/clang/test/CIR/CodeGen/agg-copy.c
index f33d29fd1d11..d29f296d878d 100644
--- a/clang/test/CIR/CodeGen/agg-copy.c
+++ b/clang/test/CIR/CodeGen/agg-copy.c
@@ -10,53 +10,53 @@ typedef struct {
 } A;
 
 // CHECK: cir.func @foo1
-// CHECK:   [[TMP0:%.*]] = cir.alloca !cir.ptr<!ty_22A22>, !cir.ptr<!cir.ptr<!ty_22A22>>, ["a1", init]
-// CHECK:   [[TMP1:%.*]] = cir.alloca !cir.ptr<!ty_22A22>, !cir.ptr<!cir.ptr<!ty_22A22>>, ["a2", init]
-// CHECK:   cir.store %arg0, [[TMP0]] : !cir.ptr<!ty_22A22>, !cir.ptr<!cir.ptr<!ty_22A22>>
-// CHECK:   cir.store %arg1, [[TMP1]] : !cir.ptr<!ty_22A22>, !cir.ptr<!cir.ptr<!ty_22A22>>
-// CHECK:   [[TMP2:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!ty_22A22>>, !cir.ptr<!ty_22A22>
+// CHECK:   [[TMP0:%.*]] = cir.alloca !cir.ptr<!ty_A>, !cir.ptr<!cir.ptr<!ty_A>>, ["a1", init]
+// CHECK:   [[TMP1:%.*]] = cir.alloca !cir.ptr<!ty_A>, !cir.ptr<!cir.ptr<!ty_A>>, ["a2", init]
+// CHECK:   cir.store %arg0, [[TMP0]] : !cir.ptr<!ty_A>, !cir.ptr<!cir.ptr<!ty_A>>
+// CHECK:   cir.store %arg1, [[TMP1]] : !cir.ptr<!ty_A>, !cir.ptr<!cir.ptr<!ty_A>>
+// CHECK:   [[TMP2:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!ty_A>>, !cir.ptr<!ty_A>
 // CHECK:   [[TMP3:%.*]] = cir.const #cir.int<1> : !s32i
-// CHECK:   [[TMP4:%.*]] = cir.ptr_stride([[TMP2]] : !cir.ptr<!ty_22A22>, [[TMP3]] : !s32i), !cir.ptr<!ty_22A22>
-// CHECK:   [[TMP5:%.*]] = cir.load [[TMP1]] : !cir.ptr<!cir.ptr<!ty_22A22>>, !cir.ptr<!ty_22A22>
+// CHECK:   [[TMP4:%.*]] = cir.ptr_stride([[TMP2]] : !cir.ptr<!ty_A>, [[TMP3]] : !s32i), !cir.ptr<!ty_A>
+// CHECK:   [[TMP5:%.*]] = cir.load [[TMP1]] : !cir.ptr<!cir.ptr<!ty_A>>, !cir.ptr<!ty_A>
 // CHECK:   [[TMP6:%.*]] = cir.const #cir.int<1> : !s32i
-// CHECK:   [[TMP7:%.*]] = cir.ptr_stride([[TMP5]] : !cir.ptr<!ty_22A22>, [[TMP6]] : !s32i), !cir.ptr<!ty_22A22>
-// CHECK:   cir.copy [[TMP7]] to [[TMP4]] : !cir.ptr<!ty_22A22>
+// CHECK:   [[TMP7:%.*]] = cir.ptr_stride([[TMP5]] : !cir.ptr<!ty_A>, [[TMP6]] : !s32i), !cir.ptr<!ty_A>
+// CHECK:   cir.copy [[TMP7]] to [[TMP4]] : !cir.ptr<!ty_A>
 void foo1(A* a1, A* a2) {
     a1[1] = a2[1];
 }
 
 // CHECK: cir.func @foo2
-// CHECK:    [[TMP0:%.*]] = cir.alloca !cir.ptr<!ty_22A22>, !cir.ptr<!cir.ptr<!ty_22A22>>, ["a1", init]
-// CHECK:    [[TMP1:%.*]] = cir.alloca !cir.ptr<!ty_22A22>, !cir.ptr<!cir.ptr<!ty_22A22>>, ["a2", init]
-// CHECK:    cir.store %arg0, [[TMP0]] : !cir.ptr<!ty_22A22>, !cir.ptr<!cir.ptr<!ty_22A22>>
-// CHECK:    cir.store %arg1, [[TMP1]] : !cir.ptr<!ty_22A22>, !cir.ptr<!cir.ptr<!ty_22A22>>
-// CHECK:    [[TMP2:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!ty_22A22>>, !cir.ptr<!ty_22A22>
-// CHECK:    [[TMP3:%.*]] = cir.get_member [[TMP2]][2] {name = "s"} : !cir.ptr<!ty_22A22> -> !cir.ptr<!ty_22S22>
-// CHECK:    [[TMP4:%.*]] = cir.load [[TMP1]] : !cir.ptr<!cir.ptr<!ty_22A22>>, !cir.ptr<!ty_22A22>
-// CHECK:    [[TMP5:%.*]] = cir.get_member [[TMP4]][2] {name = "s"} : !cir.ptr<!ty_22A22> -> !cir.ptr<!ty_22S22>
-// CHECK:    cir.copy [[TMP5]] to [[TMP3]] : !cir.ptr<!ty_22S22>
+// CHECK:    [[TMP0:%.*]] = cir.alloca !cir.ptr<!ty_A>, !cir.ptr<!cir.ptr<!ty_A>>, ["a1", init]
+// CHECK:    [[TMP1:%.*]] = cir.alloca !cir.ptr<!ty_A>, !cir.ptr<!cir.ptr<!ty_A>>, ["a2", init]
+// CHECK:    cir.store %arg0, [[TMP0]] : !cir.ptr<!ty_A>, !cir.ptr<!cir.ptr<!ty_A>>
+// CHECK:    cir.store %arg1, [[TMP1]] : !cir.ptr<!ty_A>, !cir.ptr<!cir.ptr<!ty_A>>
+// CHECK:    [[TMP2:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!ty_A>>, !cir.ptr<!ty_A>
+// CHECK:    [[TMP3:%.*]] = cir.get_member [[TMP2]][2] {name = "s"} : !cir.ptr<!ty_A> -> !cir.ptr<!ty_S>
+// CHECK:    [[TMP4:%.*]] = cir.load [[TMP1]] : !cir.ptr<!cir.ptr<!ty_A>>, !cir.ptr<!ty_A>
+// CHECK:    [[TMP5:%.*]] = cir.get_member [[TMP4]][2] {name = "s"} : !cir.ptr<!ty_A> -> !cir.ptr<!ty_S>
+// CHECK:    cir.copy [[TMP5]] to [[TMP3]] : !cir.ptr<!ty_S>
 void foo2(A* a1, A* a2) {
     a1->s = a2->s;
 }
 
-// CHECK: cir.global external @a = #cir.zero : !ty_22A22
+// CHECK: cir.global external @a = #cir.zero : !ty_A
 // CHECK: cir.func @foo3
-// CHECK:    [[TMP0]] = cir.alloca !ty_22A22, !cir.ptr<!ty_22A22>, ["__retval"] {alignment = 4 : i64}
-// CHECK:    [[TMP1]] = cir.get_global @a : !cir.ptr<!ty_22A22>
-// CHECK:    cir.copy [[TMP1]] to [[TMP0]] : !cir.ptr<!ty_22A22>
-// CHECK:    [[TMP2]] = cir.load [[TMP0]] : !cir.ptr<!ty_22A22>, !ty_22A22
-// CHECK:    cir.return [[TMP2]] : !ty_22A22
+// CHECK:    [[TMP0]] = cir.alloca !ty_A, !cir.ptr<!ty_A>, ["__retval"] {alignment = 4 : i64}
+// CHECK:    [[TMP1]] = cir.get_global @a : !cir.ptr<!ty_A>
+// CHECK:    cir.copy [[TMP1]] to [[TMP0]] : !cir.ptr<!ty_A>
+// CHECK:    [[TMP2]] = cir.load [[TMP0]] : !cir.ptr<!ty_A>, !ty_A
+// CHECK:    cir.return [[TMP2]] : !ty_A
 A a;
 A foo3(void) {
     return a;
 }
 
 // CHECK: cir.func @foo4
-// CHECK:    [[TMP0]] = cir.alloca !cir.ptr<!ty_22A22>, !cir.ptr<!cir.ptr<!ty_22A22>>, ["a1", init]
-// CHECK:    [[TMP1]] = cir.alloca !ty_22A22, !cir.ptr<!ty_22A22>, ["a2", init]
-// CHECK:    cir.store %arg0, [[TMP0]] : !cir.ptr<!ty_22A22>, !cir.ptr<!cir.ptr<!ty_22A22>>
-// CHECK:    [[TMP2]] = cir.load deref [[TMP0]] : !cir.ptr<!cir.ptr<!ty_22A22>>, !cir.ptr<!ty_22A22>
-// CHECK:    cir.copy [[TMP2]] to [[TMP1]] : !cir.ptr<!ty_22A22>
+// CHECK:    [[TMP0]] = cir.alloca !cir.ptr<!ty_A>, !cir.ptr<!cir.ptr<!ty_A>>, ["a1", init]
+// CHECK:    [[TMP1]] = cir.alloca !ty_A, !cir.ptr<!ty_A>, ["a2", init]
+// CHECK:    cir.store %arg0, [[TMP0]] : !cir.ptr<!ty_A>, !cir.ptr<!cir.ptr<!ty_A>>
+// CHECK:    [[TMP2]] = cir.load deref [[TMP0]] : !cir.ptr<!cir.ptr<!ty_A>>, !cir.ptr<!ty_A>
+// CHECK:    cir.copy [[TMP2]] to [[TMP1]] : !cir.ptr<!ty_A>
 void foo4(A* a1) {
     A a2 = *a1;
 }
@@ -64,11 +64,11 @@ void foo4(A* a1) {
 A create() { A a; return a; }
 
 // CHECK: cir.func {{.*@foo5}}
-// CHECK:   [[TMP0:%.*]] = cir.alloca !ty_22A22, !cir.ptr<!ty_22A22>,
-// CHECK:   [[TMP1:%.*]] = cir.alloca !ty_22A22, !cir.ptr<!ty_22A22>, ["tmp"] {alignment = 4 : i64}
-// CHECK:   [[TMP2:%.*]] = cir.call @create() : () -> !ty_22A22
-// CHECK:   cir.store [[TMP2]], [[TMP1]] : !ty_22A22, !cir.ptr<!ty_22A22>
-// CHECK:   cir.copy [[TMP1]] to [[TMP0]] : !cir.ptr<!ty_22A22>
+// CHECK:   [[TMP0:%.*]] = cir.alloca !ty_A, !cir.ptr<!ty_A>,
+// CHECK:   [[TMP1:%.*]] = cir.alloca !ty_A, !cir.ptr<!ty_A>, ["tmp"] {alignment = 4 : i64}
+// CHECK:   [[TMP2:%.*]] = cir.call @create() : () -> !ty_A
+// CHECK:   cir.store [[TMP2]], [[TMP1]] : !ty_A, !cir.ptr<!ty_A>
+// CHECK:   cir.copy [[TMP1]] to [[TMP0]] : !cir.ptr<!ty_A>
 void foo5() {
     A a;
     a = create();
@@ -77,11 +77,11 @@ void foo5() {
 void foo6(A* a1) {
   A a2 = (*a1);
 // CHECK: cir.func {{.*@foo6}}
-// CHECK:   [[TMP0:%.*]] = cir.alloca !cir.ptr<!ty_22A22>, !cir.ptr<!cir.ptr<!ty_22A22>>, ["a1", init] {alignment = 8 : i64}
-// CHECK:   [[TMP1:%.*]] = cir.alloca !ty_22A22, !cir.ptr<!ty_22A22>, ["a2", init] {alignment = 4 : i64}
-// CHECK:   cir.store %arg0, [[TMP0]] : !cir.ptr<!ty_22A22>, !cir.ptr<!cir.ptr<!ty_22A22>>
-// CHECK:   [[TMP2:%.*]] = cir.load deref [[TMP0]] : !cir.ptr<!cir.ptr<!ty_22A22>>, !cir.ptr<!ty_22A22>
-// CHECK:   cir.copy [[TMP2]] to [[TMP1]] : !cir.ptr<!ty_22A22>
+// CHECK:   [[TMP0:%.*]] = cir.alloca !cir.ptr<!ty_A>, !cir.ptr<!cir.ptr<!ty_A>>, ["a1", init] {alignment = 8 : i64}
+// CHECK:   [[TMP1:%.*]] = cir.alloca !ty_A, !cir.ptr<!ty_A>, ["a2", init] {alignment = 4 : i64}
+// CHECK:   cir.store %arg0, [[TMP0]] : !cir.ptr<!ty_A>, !cir.ptr<!cir.ptr<!ty_A>>
+// CHECK:   [[TMP2:%.*]] = cir.load deref [[TMP0]] : !cir.ptr<!cir.ptr<!ty_A>>, !cir.ptr<!ty_A>
+// CHECK:   cir.copy [[TMP2]] to [[TMP1]] : !cir.ptr<!ty_A>
 }
 
 volatile A vol_a;
diff --git a/clang/test/CIR/CodeGen/agg-init.cpp b/clang/test/CIR/CodeGen/agg-init.cpp
index 5e3a6473b132..0f99c8574e0f 100644
--- a/clang/test/CIR/CodeGen/agg-init.cpp
+++ b/clang/test/CIR/CodeGen/agg-init.cpp
@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++17 -fclangir -Wno-unused-value -emit-cir %s -o %t.cir
 // RUN: FileCheck --input-file=%t.cir %s
 
-// CHECK: !ty_22yep_22 = !cir.struct<struct "yep_" {!cir.int<u, 32>, !cir.int<u, 32>}>
+// CHECK: !ty_yep_ = !cir.struct<struct "yep_" {!cir.int<u, 32>, !cir.int<u, 32>}>
 
 typedef enum xxy_ {
   xxy_Low = 0,
@@ -17,11 +17,11 @@ typedef struct yep_ {
 void use() { yop{}; }
 
 // CHECK: cir.func @_Z3usev()
-// CHECK:   %0 = cir.alloca !ty_22yep_22, !cir.ptr<!ty_22yep_22>, ["agg.tmp.ensured"] {alignment = 4 : i64}
-// CHECK:   %1 = cir.get_member %0[0] {name = "Status"} : !cir.ptr<!ty_22yep_22> -> !cir.ptr<!u32i>
+// CHECK:   %0 = cir.alloca !ty_yep_, !cir.ptr<!ty_yep_>, ["agg.tmp.ensured"] {alignment = 4 : i64}
+// CHECK:   %1 = cir.get_member %0[0] {name = "Status"} : !cir.ptr<!ty_yep_> -> !cir.ptr<!u32i>
 // CHECK:   %2 = cir.const #cir.int<0> : !u32i
 // CHECK:   cir.store %2, %1 : !u32i, !cir.ptr<!u32i>
-// CHECK:   %3 = cir.get_member %0[1] {name = "HC"} : !cir.ptr<!ty_22yep_22> -> !cir.ptr<!u32i>
+// CHECK:   %3 = cir.get_member %0[1] {name = "HC"} : !cir.ptr<!ty_yep_> -> !cir.ptr<!u32i>
 // CHECK:   %4 = cir.const #cir.int<0> : !u32i
 // CHECK:   cir.store %4, %3 : !u32i, !cir.ptr<!u32i>
 // CHECK:   cir.return
@@ -47,16 +47,16 @@ void yo() {
 }
 
 // CHECK: cir.func @_Z2yov()
-// CHECK:   %0 = cir.alloca !ty_22Yo22, !cir.ptr<!ty_22Yo22>, ["ext"] {alignment = 8 : i64}
-// CHECK:   %1 = cir.alloca !ty_22Yo22, !cir.ptr<!ty_22Yo22>, ["ext2", init] {alignment = 8 : i64}
-// CHECK:   %2 = cir.const #cir.const_struct<{#cir.int<1000070000> : !u32i, #cir.ptr<null> : !cir.ptr<!void>, #cir.int<0> : !u64i}> : !ty_22Yo22
-// CHECK:   cir.store %2, %0 : !ty_22Yo22, !cir.ptr<!ty_22Yo22>
-// CHECK:   %3 = cir.get_member %1[0] {name = "type"} : !cir.ptr<!ty_22Yo22> -> !cir.ptr<!u32i>
+// CHECK:   %0 = cir.alloca !ty_Yo, !cir.ptr<!ty_Yo>, ["ext"] {alignment = 8 : i64}
+// CHECK:   %1 = cir.alloca !ty_Yo, !cir.ptr<!ty_Yo>, ["ext2", init] {alignment = 8 : i64}
+// CHECK:   %2 = cir.const #cir.const_struct<{#cir.int<1000070000> : !u32i, #cir.ptr<null> : !cir.ptr<!void>, #cir.int<0> : !u64i}> : !ty_Yo
+// CHECK:   cir.store %2, %0 : !ty_Yo, !cir.ptr<!ty_Yo>
+// CHECK:   %3 = cir.get_member %1[0] {name = "type"} : !cir.ptr<!ty_Yo> -> !cir.ptr<!u32i>
 // CHECK:   %4 = cir.const #cir.int<1000066001> : !u32i
 // CHECK:   cir.store %4, %3 : !u32i, !cir.ptr<!u32i>
-// CHECK:   %5 = cir.get_member %1[1] {name = "next"} : !cir.ptr<!ty_22Yo22> -> !cir.ptr<!cir.ptr<!void>>
-// CHECK:   %6 = cir.cast(bitcast, %0 : !cir.ptr<!ty_22Yo22>), !cir.ptr<!void>
+// CHECK:   %5 = cir.get_member %1[1] {name = "next"} : !cir.ptr<!ty_Yo> -> !cir.ptr<!cir.ptr<!void>>
+// CHECK:   %6 = cir.cast(bitcast, %0 : !cir.ptr<!ty_Yo>), !cir.ptr<!void>
 // CHECK:   cir.store %6, %5 : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
-// CHECK:   %7 = cir.get_member %1[2] {name = "createFlags"} : !cir.ptr<!ty_22Yo22> -> !cir.ptr<!u64i>
+// CHECK:   %7 = cir.get_member %1[2] {name = "createFlags"} : !cir.ptr<!ty_Yo> -> !cir.ptr<!u64i>
 // CHECK:   %8 = cir.const #cir.int<0> : !u64i
 // CHECK:   cir.store %8, %7 : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGen/agg-init2.cpp b/clang/test/CIR/CodeGen/agg-init2.cpp
index f7f14a861ae5..644e09ae7c1b 100644
--- a/clang/test/CIR/CodeGen/agg-init2.cpp
+++ b/clang/test/CIR/CodeGen/agg-init2.cpp
@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++17 -fclangir -Wno-unused-value -emit-cir %s -o %t.cir
 // RUN: FileCheck --input-file=%t.cir %s
 
-// CHECK: !ty_22Zero22 = !cir.struct<struct "Zero" {!cir.int<u, 8>}>
+// CHECK: !ty_Zero = !cir.struct<struct "Zero" {!cir.int<u, 8>}>
 
 struct Zero {
   void yolo();
@@ -14,7 +14,7 @@ void f() {
 }
 
 // CHECK: cir.func @_Z1fv()
-// CHECK:     %0 = cir.alloca !ty_22Zero22, !cir.ptr<!ty_22Zero22>, ["z0", init]
-// CHECK:     %1 = cir.alloca !ty_22Zero22, !cir.ptr<!ty_22Zero22>, ["z1"]
-// CHECK:     cir.call @_ZN4ZeroC1Ev(%0) : (!cir.ptr<!ty_22Zero22>) -> ()
+// CHECK:     %0 = cir.alloca !ty_Zero, !cir.ptr<!ty_Zero>, ["z0", init]
+// CHECK:     %1 = cir.alloca !ty_Zero, !cir.ptr<!ty_Zero>, ["z1"]
+// CHECK:     cir.call @_ZN4ZeroC1Ev(%0) : (!cir.ptr<!ty_Zero>) -> ()
 // CHECK:     cir.return
diff --git a/clang/test/CIR/CodeGen/array-init-destroy.cpp b/clang/test/CIR/CodeGen/array-init-destroy.cpp
index 2959e0085314..9bc39cec84c0 100644
--- a/clang/test/CIR/CodeGen/array-init-destroy.cpp
+++ b/clang/test/CIR/CodeGen/array-init-destroy.cpp
@@ -20,42 +20,42 @@ void x() {
 }
 
 // BEFORE: cir.func @_Z1xv()
-// BEFORE:   %[[ArrayAddr:.*]] = cir.alloca !cir.array<!ty_22xpto22 x 2>
+// BEFORE:   %[[ArrayAddr:.*]] = cir.alloca !cir.array<!ty_xpto x 2>
 
-// BEFORE:   cir.array.ctor(%[[ArrayAddr]] : !cir.ptr<!cir.array<!ty_22xpto22 x 2>>) {
-// BEFORE:   ^bb0(%arg0: !cir.ptr<!ty_22xpto22>
-// BEFORE:     cir.call @_ZN4xptoC1Ev(%arg0) : (!cir.ptr<!ty_22xpto22>) -> ()
+// BEFORE:   cir.array.ctor(%[[ArrayAddr]] : !cir.ptr<!cir.array<!ty_xpto x 2>>) {
+// BEFORE:   ^bb0(%arg0: !cir.ptr<!ty_xpto>
+// BEFORE:     cir.call @_ZN4xptoC1Ev(%arg0) : (!cir.ptr<!ty_xpto>) -> ()
 // BEFORE:     cir.yield
 // BEFORE:   }
 
-// BEFORE:   cir.array.dtor(%[[ArrayAddr]] : !cir.ptr<!cir.array<!ty_22xpto22 x 2>>) {
-// BEFORE:   ^bb0(%arg0: !cir.ptr<!ty_22xpto22>
-// BEFORE:     cir.call @_ZN4xptoD1Ev(%arg0) : (!cir.ptr<!ty_22xpto22>) -> ()
+// BEFORE:   cir.array.dtor(%[[ArrayAddr]] : !cir.ptr<!cir.array<!ty_xpto x 2>>) {
+// BEFORE:   ^bb0(%arg0: !cir.ptr<!ty_xpto>
+// BEFORE:     cir.call @_ZN4xptoD1Ev(%arg0) : (!cir.ptr<!ty_xpto>) -> ()
 // BEFORE:     cir.yield
 // BEFORE:   }
 
 // AFTER: cir.func @_Z1xv()
-// AFTER: %[[ArrayAddr0:.*]] = cir.alloca !cir.array<!ty_22xpto22 x 2>
+// AFTER: %[[ArrayAddr0:.*]] = cir.alloca !cir.array<!ty_xpto x 2>
 // AFTER: %[[ConstTwo:.*]] = cir.const #cir.int<2> : !u64i
-// AFTER: %[[ArrayBegin:.*]] = cir.cast(array_to_ptrdecay, %[[ArrayAddr0]] : !cir.ptr<!cir.array<!ty_22xpto22 x 2>>), !cir.ptr<!ty_22xpto22>
-// AFTER: %[[ArrayPastEnd:.*]] = cir.ptr_stride(%[[ArrayBegin]] : !cir.ptr<!ty_22xpto22>, %[[ConstTwo]] : !u64i), !cir.ptr<!ty_22xpto22>
-// AFTER: %[[TmpIdx:.*]] = cir.alloca !cir.ptr<!ty_22xpto22>, !cir.ptr<!cir.ptr<!ty_22xpto22>>, ["__array_idx"] {alignment = 1 : i64}
-// AFTER: cir.store %[[ArrayBegin]], %[[TmpIdx]] : !cir.ptr<!ty_22xpto22>, !cir.ptr<!cir.ptr<!ty_22xpto22>>
+// AFTER: %[[ArrayBegin:.*]] = cir.cast(array_to_ptrdecay, %[[ArrayAddr0]] : !cir.ptr<!cir.array<!ty_xpto x 2>>), !cir.ptr<!ty_xpto>
+// AFTER: %[[ArrayPastEnd:.*]] = cir.ptr_stride(%[[ArrayBegin]] : !cir.ptr<!ty_xpto>, %[[ConstTwo]] : !u64i), !cir.ptr<!ty_xpto>
+// AFTER: %[[TmpIdx:.*]] = cir.alloca !cir.ptr<!ty_xpto>, !cir.ptr<!cir.ptr<!ty_xpto>>, ["__array_idx"] {alignment = 1 : i64}
+// AFTER: cir.store %[[ArrayBegin]], %[[TmpIdx]] : !cir.ptr<!ty_xpto>, !cir.ptr<!cir.ptr<!ty_xpto>>
 // AFTER: cir.do {
-// AFTER:   %[[ArrayElt:.*]] = cir.load %[[TmpIdx]] : !cir.ptr<!cir.ptr<!ty_22xpto22>>, !cir.ptr<!ty_22xpto22>
+// AFTER:   %[[ArrayElt:.*]] = cir.load %[[TmpIdx]] : !cir.ptr<!cir.ptr<!ty_xpto>>, !cir.ptr<!ty_xpto>
 // AFTER:   %[[ConstOne:.*]] = cir.const #cir.int<1> : !u64i
-// AFTER:   cir.call @_ZN4xptoC1Ev(%[[ArrayElt]]) : (!cir.ptr<!ty_22xpto22>) -> ()
-// AFTER:   %[[NextElt:.*]] = cir.ptr_stride(%[[ArrayElt]] : !cir.ptr<!ty_22xpto22>, %[[ConstOne]] : !u64i), !cir.ptr<!ty_22xpto22>
-// AFTER:   cir.store %[[NextElt]], %[[TmpIdx]] : !cir.ptr<!ty_22xpto22>, !cir.ptr<!cir.ptr<!ty_22xpto22>>
+// AFTER:   cir.call @_ZN4xptoC1Ev(%[[ArrayElt]]) : (!cir.ptr<!ty_xpto>) -> ()
+// AFTER:   %[[NextElt:.*]] = cir.ptr_stride(%[[ArrayElt]] : !cir.ptr<!ty_xpto>, %[[ConstOne]] : !u64i), !cir.ptr<!ty_xpto>
+// AFTER:   cir.store %[[NextElt]], %[[TmpIdx]] : !cir.ptr<!ty_xpto>, !cir.ptr<!cir.ptr<!ty_xpto>>
 // AFTER:   cir.yield
 // AFTER: } while {
-// AFTER:   %[[ArrayElt:.*]] = cir.load %[[TmpIdx]] : !cir.ptr<!cir.ptr<!ty_22xpto22>>, !cir.ptr<!ty_22xpto22>
-// AFTER:   %[[ExitCond:.*]] = cir.cmp(eq, %[[ArrayElt]], %[[ArrayPastEnd]]) : !cir.ptr<!ty_22xpto22>, !cir.bool
+// AFTER:   %[[ArrayElt:.*]] = cir.load %[[TmpIdx]] : !cir.ptr<!cir.ptr<!ty_xpto>>, !cir.ptr<!ty_xpto>
+// AFTER:   %[[ExitCond:.*]] = cir.cmp(eq, %[[ArrayElt]], %[[ArrayPastEnd]]) : !cir.ptr<!ty_xpto>, !cir.bool
 // AFTER:   cir.condition(%[[ExitCond]])
 // AFTER: }
 
 // AFTER: cir.do {
-// AFTER:   cir.call @_ZN4xptoD1Ev({{.*}}) : (!cir.ptr<!ty_22xpto22>) -> ()
+// AFTER:   cir.call @_ZN4xptoD1Ev({{.*}}) : (!cir.ptr<!ty_xpto>) -> ()
 // AFTER: } while {
 // AFTER: }
 
diff --git a/clang/test/CIR/CodeGen/array-init.c b/clang/test/CIR/CodeGen/array-init.c
index d805d4ea1f4a..13999f24a45d 100644
--- a/clang/test/CIR/CodeGen/array-init.c
+++ b/clang/test/CIR/CodeGen/array-init.c
@@ -10,20 +10,20 @@ void buz(int x) {
 }
 // CHECK: cir.func @buz
 // CHECK-NEXT: [[X_ALLOCA:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
-// CHECK-NEXT: [[ARR:%.*]] = cir.alloca !cir.array<!ty_22T22 x 2>, !cir.ptr<!cir.array<!ty_22T22 x 2>>, ["arr", init] {alignment = 16 : i64}
+// CHECK-NEXT: [[ARR:%.*]] = cir.alloca !cir.array<!ty_T x 2>, !cir.ptr<!cir.array<!ty_T x 2>>, ["arr", init] {alignment = 16 : i64}
 // CHECK-NEXT: cir.store %arg0, [[X_ALLOCA]] : !s32i, !cir.ptr<!s32i>
-// CHECK-NEXT: [[ARR_INIT:%.*]] = cir.const #cir.zero : !cir.array<!ty_22T22 x 2>
-// CHECK-NEXT: cir.store [[ARR_INIT]], [[ARR]] : !cir.array<!ty_22T22 x 2>, !cir.ptr<!cir.array<!ty_22T22 x 2>>
-// CHECK-NEXT: [[FI_EL:%.*]] = cir.cast(array_to_ptrdecay, [[ARR]] : !cir.ptr<!cir.array<!ty_22T22 x 2>>), !cir.ptr<!ty_22T22>
-// CHECK-NEXT: [[A_STORAGE0:%.*]] = cir.get_member [[FI_EL]][0] {name = "a"} : !cir.ptr<!ty_22T22> -> !cir.ptr<!s32i>
-// CHECK-NEXT: [[B_STORAGE0:%.*]] = cir.get_member [[FI_EL]][1] {name = "b"} : !cir.ptr<!ty_22T22> -> !cir.ptr<!s64i>
+// CHECK-NEXT: [[ARR_INIT:%.*]] = cir.const #cir.zero : !cir.array<!ty_T x 2>
+// CHECK-NEXT: cir.store [[ARR_INIT]], [[ARR]] : !cir.array<!ty_T x 2>, !cir.ptr<!cir.array<!ty_T x 2>>
+// CHECK-NEXT: [[FI_EL:%.*]] = cir.cast(array_to_ptrdecay, [[ARR]] : !cir.ptr<!cir.array<!ty_T x 2>>), !cir.ptr<!ty_T>
+// CHECK-NEXT: [[A_STORAGE0:%.*]] = cir.get_member [[FI_EL]][0] {name = "a"} : !cir.ptr<!ty_T> -> !cir.ptr<!s32i>
+// CHECK-NEXT: [[B_STORAGE0:%.*]] = cir.get_member [[FI_EL]][1] {name = "b"} : !cir.ptr<!ty_T> -> !cir.ptr<!s64i>
 // CHECK-NEXT: [[X_VAL:%.*]] = cir.load [[X_ALLOCA]] : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT: [[X_CASTED:%.*]] = cir.cast(integral, [[X_VAL]] : !s32i), !s64i
 // CHECK-NEXT: cir.store [[X_CASTED]], [[B_STORAGE0]] : !s64i, !cir.ptr<!s64i>
 // CHECK-NEXT: [[ONE:%.*]] = cir.const #cir.int<1> : !s64i
-// CHECK-NEXT: [[SE_EL:%.*]] = cir.ptr_stride([[FI_EL]] : !cir.ptr<!ty_22T22>, [[ONE]] : !s64i), !cir.ptr<!ty_22T22>
-// CHECK-NEXT: [[A_STORAGE1:%.*]] = cir.get_member [[SE_EL]][0] {name = "a"} : !cir.ptr<!ty_22T22> -> !cir.ptr<!s32i>
-// CHECK-NEXT: [[B_STORAGE1:%.*]] = cir.get_member [[SE_EL]][1] {name = "b"} : !cir.ptr<!ty_22T22> -> !cir.ptr<!s64i>
+// CHECK-NEXT: [[SE_EL:%.*]] = cir.ptr_stride([[FI_EL]] : !cir.ptr<!ty_T>, [[ONE]] : !s64i), !cir.ptr<!ty_T>
+// CHECK-NEXT: [[A_STORAGE1:%.*]] = cir.get_member [[SE_EL]][0] {name = "a"} : !cir.ptr<!ty_T> -> !cir.ptr<!s32i>
+// CHECK-NEXT: [[B_STORAGE1:%.*]] = cir.get_member [[SE_EL]][1] {name = "b"} : !cir.ptr<!ty_T> -> !cir.ptr<!s64i>
 // CHECK-NEXT: cir.return
 
 void foo() {
diff --git a/clang/test/CIR/CodeGen/array.c b/clang/test/CIR/CodeGen/array.c
index 5079f687b2f5..ed83c663bd60 100644
--- a/clang/test/CIR/CodeGen/array.c
+++ b/clang/test/CIR/CodeGen/array.c
@@ -5,7 +5,7 @@
 struct S {
   int i;
 } arr[3] = {{1}};
-// CHECK: cir.global external @arr = #cir.const_array<[#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_22S22, #cir.zero : !ty_22S22, #cir.zero : !ty_22S22]> : !cir.array<!ty_22S22 x 3>
+// CHECK: cir.global external @arr = #cir.const_array<[#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_S, #cir.zero : !ty_S, #cir.zero : !ty_S]> : !cir.array<!ty_S x 3>
 
 int a[4];
 // CHECK: cir.global external @a = #cir.zero : !cir.array<!s32i x 4> 
diff --git a/clang/test/CIR/CodeGen/array.cpp b/clang/test/CIR/CodeGen/array.cpp
index 1fc6989058ae..b0807755cfec 100644
--- a/clang/test/CIR/CodeGen/array.cpp
+++ b/clang/test/CIR/CodeGen/array.cpp
@@ -70,7 +70,7 @@ int globalNullArr[] = {0, 0};
 struct S {
   int i;
 } arr[3] = {{1}};
-// CHECK: cir.global external @arr = #cir.const_array<[#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_22S22, #cir.zero : !ty_22S22, #cir.zero : !ty_22S22]> : !cir.array<!ty_22S22 x 3>
+// CHECK: cir.global external @arr = #cir.const_array<[#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_S, #cir.zero : !ty_S, #cir.zero : !ty_S]> : !cir.array<!ty_S x 3>
 
 void testPointerDecaySubscriptAccess(int arr[]) {
 // CHECK: cir.func @{{.+}}testPointerDecaySubscriptAccess
diff --git a/clang/test/CIR/CodeGen/asm.c b/clang/test/CIR/CodeGen/asm.c
index 2079f9b0573d..19b9c7d18637 100644
--- a/clang/test/CIR/CodeGen/asm.c
+++ b/clang/test/CIR/CodeGen/asm.c
@@ -51,7 +51,7 @@ void empty5(int x) {
 // CHECK:   out = [],
 // CHECK:   in = [],
 // CHECK:   in_out = [%2 : !s32i],
-// CHECK:   {"" "=&r,=&r,1,~{dirflag},~{fpsr},~{flags}"}) side_effects -> !ty_22anon2E022
+// CHECK:   {"" "=&r,=&r,1,~{dirflag},~{fpsr},~{flags}"}) side_effects -> !ty_anon2E0_
 void empty6(int x) {
   __asm__ volatile("" : "=&r"(x), "+&r"(x));
 }
diff --git a/clang/test/CIR/CodeGen/assign-operator.cpp b/clang/test/CIR/CodeGen/assign-operator.cpp
index a90642945562..5942beb296dc 100644
--- a/clang/test/CIR/CodeGen/assign-operator.cpp
+++ b/clang/test/CIR/CodeGen/assign-operator.cpp
@@ -15,11 +15,11 @@ struct String {
   // StringView::StringView(String const&)
   //
   // CHECK: cir.func linkonce_odr @_ZN10StringViewC2ERK6String
-  // CHECK:   %0 = cir.alloca !cir.ptr<!ty_22StringView22>, !cir.ptr<!cir.ptr<!ty_22StringView22>>, ["this", init] {alignment = 8 : i64}
-  // CHECK:   %1 = cir.alloca !cir.ptr<!ty_22String22>, !cir.ptr<!cir.ptr<!ty_22String22>>, ["s", init] {alignment = 8 : i64}
-  // CHECK:   cir.store %arg0, %0 : !cir.ptr<!ty_22StringView22>
-  // CHECK:   cir.store %arg1, %1 : !cir.ptr<!ty_22String22>
-  // CHECK:   %2 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22StringView22>>
+  // CHECK:   %0 = cir.alloca !cir.ptr<!ty_StringView>, !cir.ptr<!cir.ptr<!ty_StringView>>, ["this", init] {alignment = 8 : i64}
+  // CHECK:   %1 = cir.alloca !cir.ptr<!ty_String>, !cir.ptr<!cir.ptr<!ty_String>>, ["s", init] {alignment = 8 : i64}
+  // CHECK:   cir.store %arg0, %0 : !cir.ptr<!ty_StringView>
+  // CHECK:   cir.store %arg1, %1 : !cir.ptr<!ty_String>
+  // CHECK:   %2 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_StringView>>
 
   // Get address of `this->size`
 
@@ -27,7 +27,7 @@ struct String {
 
   // Get address of `s`
 
-  // CHECK:   %4 = cir.load %1 : !cir.ptr<!cir.ptr<!ty_22String22>>
+  // CHECK:   %4 = cir.load %1 : !cir.ptr<!cir.ptr<!ty_String>>
 
   // Get the address of s.size
 
@@ -41,25 +41,25 @@ struct String {
   // CHECK: }
 
   // DISABLE: cir.func linkonce_odr @_ZN10StringViewC2ERK6String
-  // DISABLE-NEXT:   %0 = cir.alloca !cir.ptr<!ty_22StringView22>, !cir.ptr<!cir.ptr<!ty_22StringView22>>, ["this", init] {alignment = 8 : i64}
+  // DISABLE-NEXT:   %0 = cir.alloca !cir.ptr<!ty_StringView>, !cir.ptr<!cir.ptr<!ty_StringView>>, ["this", init] {alignment = 8 : i64}
 
   // StringView::operator=(StringView&&)
   //
   // CHECK: cir.func linkonce_odr @_ZN10StringViewaSEOS_
-  // CHECK:   %0 = cir.alloca !cir.ptr<!ty_22StringView22>, !cir.ptr<!cir.ptr<!ty_22StringView22>>, ["this", init] {alignment = 8 : i64}
-  // CHECK:   %1 = cir.alloca !cir.ptr<!ty_22StringView22>, !cir.ptr<!cir.ptr<!ty_22StringView22>>, ["", init] {alignment = 8 : i64}
-  // CHECK:   %2 = cir.alloca !cir.ptr<!ty_22StringView22>, !cir.ptr<!cir.ptr<!ty_22StringView22>>, ["__retval"] {alignment = 8 : i64}
-  // CHECK:   cir.store %arg0, %0 : !cir.ptr<!ty_22StringView22>
-  // CHECK:   cir.store %arg1, %1 : !cir.ptr<!ty_22StringView22>
-  // CHECK:   %3 = cir.load deref %0 : !cir.ptr<!cir.ptr<!ty_22StringView22>>
-  // CHECK:   %4 = cir.load %1 : !cir.ptr<!cir.ptr<!ty_22StringView22>>
+  // CHECK:   %0 = cir.alloca !cir.ptr<!ty_StringView>, !cir.ptr<!cir.ptr<!ty_StringView>>, ["this", init] {alignment = 8 : i64}
+  // CHECK:   %1 = cir.alloca !cir.ptr<!ty_StringView>, !cir.ptr<!cir.ptr<!ty_StringView>>, ["", init] {alignment = 8 : i64}
+  // CHECK:   %2 = cir.alloca !cir.ptr<!ty_StringView>, !cir.ptr<!cir.ptr<!ty_StringView>>, ["__retval"] {alignment = 8 : i64}
+  // CHECK:   cir.store %arg0, %0 : !cir.ptr<!ty_StringView>
+  // CHECK:   cir.store %arg1, %1 : !cir.ptr<!ty_StringView>
+  // CHECK:   %3 = cir.load deref %0 : !cir.ptr<!cir.ptr<!ty_StringView>>
+  // CHECK:   %4 = cir.load %1 : !cir.ptr<!cir.ptr<!ty_StringView>>
   // CHECK:   %5 = cir.get_member %4[0] {name = "size"}
   // CHECK:   %6 = cir.load %5 : !cir.ptr<!s64i>, !s64i
   // CHECK:   %7 = cir.get_member %3[0] {name = "size"}
   // CHECK:   cir.store %6, %7 : !s64i, !cir.ptr<!s64i>
-  // CHECK:   cir.store %3, %2 : !cir.ptr<!ty_22StringView22>
-  // CHECK:   %8 = cir.load %2 : !cir.ptr<!cir.ptr<!ty_22StringView22>>
-  // CHECK:   cir.return %8 : !cir.ptr<!ty_22StringView22>
+  // CHECK:   cir.store %3, %2 : !cir.ptr<!ty_StringView>
+  // CHECK:   %8 = cir.load %2 : !cir.ptr<!cir.ptr<!ty_StringView>>
+  // CHECK:   cir.return %8 : !cir.ptr<!ty_StringView>
   // CHECK: }
 
   // DISABLE: cir.func private @_ZN10StringViewaSEOS_
@@ -83,17 +83,17 @@ int main() {
 
 // CHECK: cir.func @main() -> !s32i
 // CHECK:     %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
-// CHECK:     %1 = cir.alloca !ty_22StringView22, !cir.ptr<!ty_22StringView22>, ["sv", init] {alignment = 8 : i64}
-// CHECK:     cir.call @_ZN10StringViewC2Ev(%1) : (!cir.ptr<!ty_22StringView22>) -> ()
+// CHECK:     %1 = cir.alloca !ty_StringView, !cir.ptr<!ty_StringView>, ["sv", init] {alignment = 8 : i64}
+// CHECK:     cir.call @_ZN10StringViewC2Ev(%1) : (!cir.ptr<!ty_StringView>) -> ()
 // CHECK:     cir.scope {
-// CHECK:       %3 = cir.alloca !ty_22String22, !cir.ptr<!ty_22String22>, ["s", init] {alignment = 8 : i64}
+// CHECK:       %3 = cir.alloca !ty_String, !cir.ptr<!ty_String>, ["s", init] {alignment = 8 : i64}
 // CHECK:       %4 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 3>>
 // CHECK:       %5 = cir.cast(array_to_ptrdecay, %4 : !cir.ptr<!cir.array<!s8i x 3>>), !cir.ptr<!s8i>
-// CHECK:       cir.call @_ZN6StringC2EPKc(%3, %5) : (!cir.ptr<!ty_22String22>, !cir.ptr<!s8i>) -> ()
+// CHECK:       cir.call @_ZN6StringC2EPKc(%3, %5) : (!cir.ptr<!ty_String>, !cir.ptr<!s8i>) -> ()
 // CHECK:       cir.scope {
-// CHECK:         %6 = cir.alloca !ty_22StringView22, !cir.ptr<!ty_22StringView22>, ["ref.tmp0"] {alignment = 8 : i64}
-// CHECK:         cir.call @_ZN10StringViewC2ERK6String(%6, %3) : (!cir.ptr<!ty_22StringView22>, !cir.ptr<!ty_22String22>) -> ()
-// CHECK:         %7 = cir.call @_ZN10StringViewaSEOS_(%1, %6) : (!cir.ptr<!ty_22StringView22>, !cir.ptr<!ty_22StringView22>) -> !cir.ptr<!ty_22StringView22>
+// CHECK:         %6 = cir.alloca !ty_StringView, !cir.ptr<!ty_StringView>, ["ref.tmp0"] {alignment = 8 : i64}
+// CHECK:         cir.call @_ZN10StringViewC2ERK6String(%6, %3) : (!cir.ptr<!ty_StringView>, !cir.ptr<!ty_String>) -> ()
+// CHECK:         %7 = cir.call @_ZN10StringViewaSEOS_(%1, %6) : (!cir.ptr<!ty_StringView>, !cir.ptr<!ty_StringView>) -> !cir.ptr<!ty_StringView>
 // CHECK:       }
 // CHECK:     }
 // CHECK:     %2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/CodeGen/atomic.cpp b/clang/test/CIR/CodeGen/atomic.cpp
index 43ba4e12f7ed..2e7c93e32270 100644
--- a/clang/test/CIR/CodeGen/atomic.cpp
+++ b/clang/test/CIR/CodeGen/atomic.cpp
@@ -230,7 +230,7 @@ void fd3(struct S *a, struct S *b, struct S *c) {
 }
 
 // CHECK-LABEL: @_Z3fd3P1SS0_S0_
-// CHECK: cir.atomic.xchg({{.*}} : !cir.ptr<!ty_22S22>, {{.*}} : !u64i, seq_cst) : !u64i
+// CHECK: cir.atomic.xchg({{.*}} : !cir.ptr<!ty_S>, {{.*}} : !u64i, seq_cst) : !u64i
 
 // FIXME: CIR is producing an over alignment of 8, only 4 needed.
 // LLVM-LABEL: @_Z3fd3P1SS0_S0_
@@ -252,7 +252,7 @@ bool fd4(struct S *a, struct S *b, struct S *c) {
 }
 
 // CHECK-LABEL: @_Z3fd4P1SS0_S0_
-// CHECK: %old, %cmp = cir.atomic.cmp_xchg({{.*}} : !cir.ptr<!ty_22S22>, {{.*}} : !u64i, {{.*}} : !u64i, success = seq_cst, failure = seq_cst) weak : (!u64i, !cir.bool)
+// CHECK: %old, %cmp = cir.atomic.cmp_xchg({{.*}} : !cir.ptr<!ty_S>, {{.*}} : !u64i, {{.*}} : !u64i, success = seq_cst, failure = seq_cst) weak : (!u64i, !cir.bool)
 
 // LLVM-LABEL: @_Z3fd4P1SS0_S0_
 // LLVM: cmpxchg weak ptr {{.*}}, i64 {{.*}}, i64 {{.*}} seq_cst seq_cst, align 8
diff --git a/clang/test/CIR/CodeGen/bitfield-union.c b/clang/test/CIR/CodeGen/bitfield-union.c
index d17fcbcf7e9f..882e2ad9249a 100644
--- a/clang/test/CIR/CodeGen/bitfield-union.c
+++ b/clang/test/CIR/CodeGen/bitfield-union.c
@@ -13,20 +13,20 @@ void main() {
     d.z = 0;
 }
 
-// CHECK: !ty_22demo22 = !cir.struct<union "demo" {!cir.int<s, 32>, !cir.int<u, 8>, !cir.int<u, 8>}>
+// CHECK: !ty_demo = !cir.struct<union "demo" {!cir.int<s, 32>, !cir.int<u, 8>, !cir.int<u, 8>}>
 // CHECK: #bfi_y = #cir.bitfield_info<name = "y", storage_type = !u8i, size = 4, offset = 0, is_signed = true>
 // CHECK: #bfi_z = #cir.bitfield_info<name = "z", storage_type = !u8i, size = 8, offset = 0, is_signed = true>
 
 //   cir.func no_proto @main() extra(#fn_attr) {
-//     %0 = cir.alloca !ty_22demo22, !cir.ptr<!ty_22demo22>, ["d"] {alignment = 4 : i64}
+//     %0 = cir.alloca !ty_demo, !cir.ptr<!ty_demo>, ["d"] {alignment = 4 : i64}
 //     %1 = cir.const #cir.int<1> : !s32i
-//     %2 = cir.get_member %0[0] {name = "x"} : !cir.ptr<!ty_22demo22> -> !cir.ptr<!s32i>
+//     %2 = cir.get_member %0[0] {name = "x"} : !cir.ptr<!ty_demo> -> !cir.ptr<!s32i>
 //     cir.store %1, %2 : !s32i, !cir.ptr<!s32i>
 //     %3 = cir.const #cir.int<2> : !s32i
-//     %4 = cir.cast(bitcast, %0 : !cir.ptr<!ty_22demo22>), !cir.ptr<!u8i>
+//     %4 = cir.cast(bitcast, %0 : !cir.ptr<!ty_demo>), !cir.ptr<!u8i>
 //     %5 = cir.set_bitfield(#bfi_y, %4 : !cir.ptr<!u8i>, %3 : !s32i) -> !s32i
 //     %6 = cir.const #cir.int<0> : !s32i loc(#loc10)
-//     %7 = cir.cast(bitcast, %0 : !cir.ptr<!ty_22demo22>), !cir.ptr<!u8i>
+//     %7 = cir.cast(bitcast, %0 : !cir.ptr<!ty_demo>), !cir.ptr<!u8i>
 //     %8 = cir.set_bitfield(#bfi_z, %7 : !cir.ptr<!u8i>, %6 : !s32i) -> !s32i
 //     cir.return
 //   }
diff --git a/clang/test/CIR/CodeGen/bitfields.c b/clang/test/CIR/CodeGen/bitfields.c
index ae4403af4e7c..d26eaf6105b3 100644
--- a/clang/test/CIR/CodeGen/bitfields.c
+++ b/clang/test/CIR/CodeGen/bitfields.c
@@ -53,21 +53,21 @@ typedef struct {
                // because (tail - startOffset) is 65 after 'l' field
 } U;
 
-// CHECK: !ty_22D22 = !cir.struct<struct "D" {!cir.int<u, 16>, !cir.int<s, 32>}>
-// CHECK: !ty_22T22 = !cir.struct<struct "T" {!cir.int<u, 8>, !cir.int<u, 32>} #cir.record.decl.ast>
-// CHECK: !ty_22anon2E122 = !cir.struct<struct "anon.1" {!cir.int<u, 32>} #cir.record.decl.ast>
+// CHECK: !ty_D = !cir.struct<struct "D" {!cir.int<u, 16>, !cir.int<s, 32>}>
+// CHECK: !ty_T = !cir.struct<struct "T" {!cir.int<u, 8>, !cir.int<u, 32>} #cir.record.decl.ast>
+// CHECK: !ty_anon2E1_ = !cir.struct<struct "anon.1" {!cir.int<u, 32>} #cir.record.decl.ast>
 // CHECK: !ty_anon_struct = !cir.struct<struct  {!cir.int<u, 8>, !cir.int<u, 8>, !cir.int<s, 32>}>
 // CHECK: #bfi_a = #cir.bitfield_info<name = "a", storage_type = !u8i, size = 3, offset = 0, is_signed = true>
 // CHECK: #bfi_e = #cir.bitfield_info<name = "e", storage_type = !u16i, size = 15, offset = 0, is_signed = true>
-// CHECK: !ty_22S22 = !cir.struct<struct "S" {!cir.int<u, 32>, !cir.array<!cir.int<u, 8> x 3>, !cir.int<u, 16>, !cir.int<u, 32>}>
-// CHECK: !ty_22U22 = !cir.struct<struct "U" {!cir.int<s, 8>, !cir.int<s, 8>, !cir.int<s, 8>, !cir.array<!cir.int<u, 8> x 9>}>
-// CHECK: !ty_22__long22 = !cir.struct<struct "__long" {!cir.struct<struct "anon.1" {!cir.int<u, 32>} #cir.record.decl.ast>, !cir.int<u, 32>, !cir.ptr<!cir.int<u, 32>>}>
+// CHECK: !ty_S = !cir.struct<struct "S" {!cir.int<u, 32>, !cir.array<!cir.int<u, 8> x 3>, !cir.int<u, 16>, !cir.int<u, 32>}>
+// CHECK: !ty_U = !cir.struct<struct "U" {!cir.int<s, 8>, !cir.int<s, 8>, !cir.int<s, 8>, !cir.array<!cir.int<u, 8> x 9>}>
+// CHECK: !ty___long = !cir.struct<struct "__long" {!cir.struct<struct "anon.1" {!cir.int<u, 32>} #cir.record.decl.ast>, !cir.int<u, 32>, !cir.ptr<!cir.int<u, 32>>}>
 // CHECK: #bfi_d = #cir.bitfield_info<name = "d", storage_type = !cir.array<!u8i x 3>, size = 2, offset = 17, is_signed = true>
 
 // CHECK: cir.func {{.*@store_field}}
-// CHECK:   [[TMP0:%.*]] = cir.alloca !ty_22S22, !cir.ptr<!ty_22S22>
+// CHECK:   [[TMP0:%.*]] = cir.alloca !ty_S, !cir.ptr<!ty_S>
 // CHECK:   [[TMP1:%.*]] = cir.const #cir.int<3> : !s32i
-// CHECK:   [[TMP2:%.*]] = cir.get_member [[TMP0]][2] {name = "e"} : !cir.ptr<!ty_22S22> -> !cir.ptr<!u16i>
+// CHECK:   [[TMP2:%.*]] = cir.get_member [[TMP0]][2] {name = "e"} : !cir.ptr<!ty_S> -> !cir.ptr<!u16i>
 // CHECK:   cir.set_bitfield(#bfi_e, [[TMP2]] : !cir.ptr<!u16i>, [[TMP1]] : !s32i)
 void store_field() {
   S s;
@@ -75,16 +75,16 @@ void store_field() {
 }
 
 // CHECK: cir.func {{.*@load_field}}
-// CHECK:   [[TMP0:%.*]] = cir.alloca !cir.ptr<!ty_22S22>, !cir.ptr<!cir.ptr<!ty_22S22>>, ["s", init]
-// CHECK:   [[TMP1:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!ty_22S22>>, !cir.ptr<!ty_22S22>
-// CHECK:   [[TMP2:%.*]] = cir.get_member [[TMP1]][1] {name = "d"} : !cir.ptr<!ty_22S22> -> !cir.ptr<!cir.array<!u8i x 3>>
+// CHECK:   [[TMP0:%.*]] = cir.alloca !cir.ptr<!ty_S>, !cir.ptr<!cir.ptr<!ty_S>>, ["s", init]
+// CHECK:   [[TMP1:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!ty_S>>, !cir.ptr<!ty_S>
+// CHECK:   [[TMP2:%.*]] = cir.get_member [[TMP1]][1] {name = "d"} : !cir.ptr<!ty_S> -> !cir.ptr<!cir.array<!u8i x 3>>
 // CHECK:   [[TMP3:%.*]] = cir.get_bitfield(#bfi_d, [[TMP2]] : !cir.ptr<!cir.array<!u8i x 3>>) -> !s32i
 int load_field(S* s) {
   return s->d;
 }
 
 // CHECK: cir.func {{.*@unOp}}
-// CHECK:   [[TMP0:%.*]] = cir.get_member {{.*}}[1] {name = "d"} : !cir.ptr<!ty_22S22> -> !cir.ptr<!cir.array<!u8i x 3>>
+// CHECK:   [[TMP0:%.*]] = cir.get_member {{.*}}[1] {name = "d"} : !cir.ptr<!ty_S> -> !cir.ptr<!cir.array<!u8i x 3>>
 // CHECK:   [[TMP1:%.*]] = cir.get_bitfield(#bfi_d, [[TMP0]] : !cir.ptr<!cir.array<!u8i x 3>>) -> !s32i
 // CHECK:   [[TMP2:%.*]] = cir.unary(inc, [[TMP1]]) : !s32i, !s32i
 // CHECK:   cir.set_bitfield(#bfi_d, [[TMP0]] : !cir.ptr<!cir.array<!u8i x 3>>, [[TMP2]] : !s32i)
@@ -94,7 +94,7 @@ void unOp(S* s) {
 
 // CHECK: cir.func {{.*@binOp}}
 // CHECK:   [[TMP0:%.*]] = cir.const #cir.int<42> : !s32i
-// CHECK:   [[TMP1:%.*]] = cir.get_member {{.*}}[1] {name = "d"} : !cir.ptr<!ty_22S22> -> !cir.ptr<!cir.array<!u8i x 3>>
+// CHECK:   [[TMP1:%.*]] = cir.get_member {{.*}}[1] {name = "d"} : !cir.ptr<!ty_S> -> !cir.ptr<!cir.array<!u8i x 3>>
 // CHECK:   [[TMP2:%.*]] = cir.get_bitfield(#bfi_d, [[TMP1]] : !cir.ptr<!cir.array<!u8i x 3>>) -> !s32i
 // CHECK:   [[TMP3:%.*]] = cir.binop(or, [[TMP2]], [[TMP0]]) : !s32i
 // CHECK:   cir.set_bitfield(#bfi_d, [[TMP1]] : !cir.ptr<!cir.array<!u8i x 3>>, [[TMP3]] : !s32i)
@@ -104,7 +104,7 @@ void binOp(S* s) {
 
 
 // CHECK: cir.func {{.*@load_non_bitfield}}
-// CHECK:   cir.get_member {{%.}}[3] {name = "f"} : !cir.ptr<!ty_22S22> -> !cir.ptr<!u32i>
+// CHECK:   cir.get_member {{%.}}[3] {name = "f"} : !cir.ptr<!ty_S> -> !cir.ptr<!u32i>
 unsigned load_non_bitfield(S *s) {
   return s->f;
 }
@@ -122,8 +122,8 @@ void createU() {
 
 // for this struct type we create an anon structure with different storage types in initialization
 // CHECK: cir.func {{.*@createD}}
-// CHECK:   %0 = cir.alloca !ty_22D22, !cir.ptr<!ty_22D22>, ["d"] {alignment = 4 : i64}
-// CHECK:   %1 = cir.cast(bitcast, %0 : !cir.ptr<!ty_22D22>), !cir.ptr<!ty_anon_struct>
+// CHECK:   %0 = cir.alloca !ty_D, !cir.ptr<!ty_D>, ["d"] {alignment = 4 : i64}
+// CHECK:   %1 = cir.cast(bitcast, %0 : !cir.ptr<!ty_D>), !cir.ptr<!ty_anon_struct>
 // CHECK:   %2 = cir.const #cir.const_struct<{#cir.int<33> : !u8i, #cir.int<0> : !u8i, #cir.int<3> : !s32i}> : !ty_anon_struct
 // CHECK:   cir.store %2, %1 : !ty_anon_struct, !cir.ptr<!ty_anon_struct>
 void createD() {
diff --git a/clang/test/CIR/CodeGen/bitfields.cpp b/clang/test/CIR/CodeGen/bitfields.cpp
index f87b1e8e4acd..18c8d28fca34 100644
--- a/clang/test/CIR/CodeGen/bitfields.cpp
+++ b/clang/test/CIR/CodeGen/bitfields.cpp
@@ -27,15 +27,15 @@ typedef struct {
   int a : 3;  // one bitfield with size < 8
   unsigned b;
 } T;
-// CHECK: !ty_22T22 = !cir.struct<struct "T" {!cir.int<u, 8>, !cir.int<u, 32>} #cir.record.decl.ast>
-// CHECK: !ty_22anon2E122 = !cir.struct<struct "anon.1" {!cir.int<u, 32>} #cir.record.decl.ast>
-// CHECK: !ty_22S22 = !cir.struct<struct "S" {!cir.int<u, 32>, !cir.array<!cir.int<u, 8> x 3>, !cir.int<u, 16>, !cir.int<u, 32>}>
-// CHECK: !ty_22__long22 = !cir.struct<struct "__long" {!cir.struct<struct "anon.1" {!cir.int<u, 32>} #cir.record.decl.ast>, !cir.int<u, 32>, !cir.ptr<!cir.int<u, 32>>}>
+// CHECK: !ty_T = !cir.struct<struct "T" {!cir.int<u, 8>, !cir.int<u, 32>} #cir.record.decl.ast>
+// CHECK: !ty_anon2E1_ = !cir.struct<struct "anon.1" {!cir.int<u, 32>} #cir.record.decl.ast>
+// CHECK: !ty_S = !cir.struct<struct "S" {!cir.int<u, 32>, !cir.array<!cir.int<u, 8> x 3>, !cir.int<u, 16>, !cir.int<u, 32>}>
+// CHECK: !ty___long = !cir.struct<struct "__long" {!cir.struct<struct "anon.1" {!cir.int<u, 32>} #cir.record.decl.ast>, !cir.int<u, 32>, !cir.ptr<!cir.int<u, 32>>}>
 
 // CHECK: cir.func @_Z11store_field
-// CHECK:   [[TMP0:%.*]] = cir.alloca !ty_22S22, !cir.ptr<!ty_22S22>
+// CHECK:   [[TMP0:%.*]] = cir.alloca !ty_S, !cir.ptr<!ty_S>
 // CHECK:   [[TMP1:%.*]] = cir.const #cir.int<3> : !s32i
-// CHECK:   [[TMP2:%.*]] = cir.cast(bitcast, [[TMP0]] : !cir.ptr<!ty_22S22>), !cir.ptr<!u32i>
+// CHECK:   [[TMP2:%.*]] = cir.cast(bitcast, [[TMP0]] : !cir.ptr<!ty_S>), !cir.ptr<!u32i>
 // CHECK:   cir.set_bitfield(#bfi_a, [[TMP2]] : !cir.ptr<!u32i>, [[TMP1]] : !s32i)
 void store_field() {
   S s;
@@ -43,16 +43,16 @@ void store_field() {
 }
 
 // CHECK: cir.func @_Z10load_field
-// CHECK:   [[TMP0:%.*]] = cir.alloca !cir.ptr<!ty_22S22>, !cir.ptr<!cir.ptr<!ty_22S22>>, ["s", init]
-// CHECK:   [[TMP1:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!ty_22S22>>, !cir.ptr<!ty_22S22>
-// CHECK:   [[TMP2:%.*]] = cir.get_member [[TMP1]][1] {name = "d"} : !cir.ptr<!ty_22S22> -> !cir.ptr<!cir.array<!u8i x 3>>
+// CHECK:   [[TMP0:%.*]] = cir.alloca !cir.ptr<!ty_S>, !cir.ptr<!cir.ptr<!ty_S>>, ["s", init]
+// CHECK:   [[TMP1:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!ty_S>>, !cir.ptr<!ty_S>
+// CHECK:   [[TMP2:%.*]] = cir.get_member [[TMP1]][1] {name = "d"} : !cir.ptr<!ty_S> -> !cir.ptr<!cir.array<!u8i x 3>>
 // CHECK:   [[TMP3:%.*]] = cir.get_bitfield(#bfi_d, [[TMP2]] : !cir.ptr<!cir.array<!u8i x 3>>) -> !s32i
 int load_field(S& s) {
   return s.d;
 }
 
 // CHECK: cir.func @_Z17load_non_bitfield
-// CHECK:   cir.get_member {{%.}}[3] {name = "f"} : !cir.ptr<!ty_22S22> -> !cir.ptr<!u32i>
+// CHECK:   cir.get_member {{%.}}[3] {name = "f"} : !cir.ptr<!ty_S> -> !cir.ptr<!u32i>
 unsigned load_non_bitfield(S& s) {
   return s.f;
 }
diff --git a/clang/test/CIR/CodeGen/bool.c b/clang/test/CIR/CodeGen/bool.c
index 038de348797b..c31b04f27c27 100644
--- a/clang/test/CIR/CodeGen/bool.c
+++ b/clang/test/CIR/CodeGen/bool.c
@@ -8,31 +8,31 @@ typedef struct {
 } S;
 
 // CHECK:  cir.func @init_bool
-// CHECK:    [[ALLOC:%.*]] = cir.alloca !ty_22S22, !cir.ptr<!ty_22S22>
-// CHECK:    [[ZERO:%.*]] = cir.const #cir.zero : !ty_22S22
-// CHECK:    cir.store [[ZERO]], [[ALLOC]] : !ty_22S22, !cir.ptr<!ty_22S22>
+// CHECK:    [[ALLOC:%.*]] = cir.alloca !ty_S, !cir.ptr<!ty_S>
+// CHECK:    [[ZERO:%.*]] = cir.const #cir.zero : !ty_S
+// CHECK:    cir.store [[ZERO]], [[ALLOC]] : !ty_S, !cir.ptr<!ty_S>
 void init_bool(void) {
   S s = {0};
 }
 
 // CHECK:  cir.func @store_bool
-// CHECK:    [[TMP0:%.*]] = cir.alloca !cir.ptr<!ty_22S22>, !cir.ptr<!cir.ptr<!ty_22S22>>
-// CHECK:    cir.store %arg0, [[TMP0]] : !cir.ptr<!ty_22S22>, !cir.ptr<!cir.ptr<!ty_22S22>>
+// CHECK:    [[TMP0:%.*]] = cir.alloca !cir.ptr<!ty_S>, !cir.ptr<!cir.ptr<!ty_S>>
+// CHECK:    cir.store %arg0, [[TMP0]] : !cir.ptr<!ty_S>, !cir.ptr<!cir.ptr<!ty_S>>
 // CHECK:    [[TMP1:%.*]] = cir.const #cir.int<0> : !s32i
 // CHECK:    [[TMP2:%.*]] = cir.cast(int_to_bool, [[TMP1]] : !s32i), !cir.bool
-// CHECK:    [[TMP3:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!ty_22S22>>, !cir.ptr<!ty_22S22>
-// CHECK:    [[TMP4:%.*]] = cir.get_member [[TMP3]][0] {name = "x"} : !cir.ptr<!ty_22S22> -> !cir.ptr<!cir.bool>
+// CHECK:    [[TMP3:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!ty_S>>, !cir.ptr<!ty_S>
+// CHECK:    [[TMP4:%.*]] = cir.get_member [[TMP3]][0] {name = "x"} : !cir.ptr<!ty_S> -> !cir.ptr<!cir.bool>
 // CHECK:    cir.store [[TMP2]], [[TMP4]] : !cir.bool, !cir.ptr<!cir.bool>
 void store_bool(S *s) {
   s->x = false;
 }
 
 // CHECK:  cir.func @load_bool
-// CHECK:    [[TMP0:%.*]] = cir.alloca !cir.ptr<!ty_22S22>, !cir.ptr<!cir.ptr<!ty_22S22>>, ["s", init] {alignment = 8 : i64}
+// CHECK:    [[TMP0:%.*]] = cir.alloca !cir.ptr<!ty_S>, !cir.ptr<!cir.ptr<!ty_S>>, ["s", init] {alignment = 8 : i64}
 // CHECK:    [[TMP1:%.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init] {alignment = 1 : i64}
-// CHECK:    cir.store %arg0, [[TMP0]] : !cir.ptr<!ty_22S22>, !cir.ptr<!cir.ptr<!ty_22S22>>
-// CHECK:    [[TMP2:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!ty_22S22>>, !cir.ptr<!ty_22S22>
-// CHECK:    [[TMP3:%.*]] = cir.get_member [[TMP2]][0] {name = "x"} : !cir.ptr<!ty_22S22> -> !cir.ptr<!cir.bool>
+// CHECK:    cir.store %arg0, [[TMP0]] : !cir.ptr<!ty_S>, !cir.ptr<!cir.ptr<!ty_S>>
+// CHECK:    [[TMP2:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!ty_S>>, !cir.ptr<!ty_S>
+// CHECK:    [[TMP3:%.*]] = cir.get_member [[TMP2]][0] {name = "x"} : !cir.ptr<!ty_S> -> !cir.ptr<!cir.bool>
 // CHECK:    [[TMP4:%.*]] = cir.load [[TMP3]] : !cir.ptr<!cir.bool>, !cir.bool
 void load_bool(S *s) {
   bool x = s->x;
diff --git a/clang/test/CIR/CodeGen/build-deferred.cpp b/clang/test/CIR/CodeGen/build-deferred.cpp
index bf0f2ce30c9e..f62d8ddc5c99 100644
--- a/clang/test/CIR/CodeGen/build-deferred.cpp
+++ b/clang/test/CIR/CodeGen/build-deferred.cpp
@@ -24,4 +24,4 @@ void test() {
 // CHECK-NOT: cir.func linkonce_odr @_ZN6StringC1EPKc
 
 // CHECK: cir.func @_Z4testv()
-// CHECK:   cir.call @_ZN6StringC1Ev(%0) : (!cir.ptr<!ty_22String22>) -> ()
\ No newline at end of file
+// CHECK:   cir.call @_ZN6StringC1Ev(%0) : (!cir.ptr<!ty_String>) -> ()
\ No newline at end of file
diff --git a/clang/test/CIR/CodeGen/builtin-bit-cast.cpp b/clang/test/CIR/CodeGen/builtin-bit-cast.cpp
index 88e584a2d72c..696b472a159f 100644
--- a/clang/test/CIR/CodeGen/builtin-bit-cast.cpp
+++ b/clang/test/CIR/CodeGen/builtin-bit-cast.cpp
@@ -28,8 +28,8 @@ unsigned long test_aggregate_to_scalar(two_ints &ti) {
 }
 
 // CIR-LABEL: cir.func @_Z24test_aggregate_to_scalarR8two_ints
-//       CIR:   %[[#SRC_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_22two_ints22>>, !cir.ptr<!ty_22two_ints22>
-//  CIR-NEXT:   %[[#DST_PTR:]] = cir.cast(bitcast, %[[#SRC_PTR]] : !cir.ptr<!ty_22two_ints22>), !cir.ptr<!u64i>
+//       CIR:   %[[#SRC_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_two_ints>>, !cir.ptr<!ty_two_ints>
+//  CIR-NEXT:   %[[#DST_PTR:]] = cir.cast(bitcast, %[[#SRC_PTR]] : !cir.ptr<!ty_two_ints>), !cir.ptr<!u64i>
 //  CIR-NEXT:   %{{.+}} = cir.load %[[#DST_PTR]] : !cir.ptr<!u64i>, !u64i
 //       CIR: }
 
@@ -48,9 +48,9 @@ two_floats test_aggregate_record(two_ints& ti) {
 }
 
 // CIR-LABEL: cir.func @_Z21test_aggregate_recordR8two_ints
-//       CIR:   %[[#SRC_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_22two_ints22>>, !cir.ptr<!ty_22two_ints22>
-//  CIR-NEXT:   %[[#SRC_VOID_PTR:]] = cir.cast(bitcast, %[[#SRC_PTR]] : !cir.ptr<!ty_22two_ints22>), !cir.ptr<!void>
-//  CIR-NEXT:   %[[#DST_VOID_PTR:]] = cir.cast(bitcast, %{{.+}} : !cir.ptr<!ty_22two_floats22>), !cir.ptr<!void>
+//       CIR:   %[[#SRC_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_two_ints>>, !cir.ptr<!ty_two_ints>
+//  CIR-NEXT:   %[[#SRC_VOID_PTR:]] = cir.cast(bitcast, %[[#SRC_PTR]] : !cir.ptr<!ty_two_ints>), !cir.ptr<!void>
+//  CIR-NEXT:   %[[#DST_VOID_PTR:]] = cir.cast(bitcast, %{{.+}} : !cir.ptr<!ty_two_floats>), !cir.ptr<!void>
 //  CIR-NEXT:   %[[#SIZE:]] = cir.const #cir.int<8> : !u64i
 //  CIR-NEXT:   cir.libc.memcpy %[[#SIZE]] bytes from %[[#SRC_VOID_PTR]] to %[[#DST_VOID_PTR]] : !u64i, !cir.ptr<!void> -> !cir.ptr<!void>
 //       CIR: }
@@ -69,7 +69,7 @@ two_floats test_aggregate_array(int (&ary)[2]) {
 // CIR-LABEL: cir.func @_Z20test_aggregate_arrayRA2_i
 //       CIR:   %[[#SRC_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!cir.array<!s32i x 2>>>, !cir.ptr<!cir.array<!s32i x 2>>
 //  CIR-NEXT:   %[[#SRC_VOID_PTR:]] = cir.cast(bitcast, %[[#SRC_PTR]] : !cir.ptr<!cir.array<!s32i x 2>>), !cir.ptr<!void>
-//  CIR-NEXT:   %[[#DST_VOID_PTR:]] = cir.cast(bitcast, %{{.+}} : !cir.ptr<!ty_22two_floats22>), !cir.ptr<!void>
+//  CIR-NEXT:   %[[#DST_VOID_PTR:]] = cir.cast(bitcast, %{{.+}} : !cir.ptr<!ty_two_floats>), !cir.ptr<!void>
 //  CIR-NEXT:   %[[#SIZE:]] = cir.const #cir.int<8> : !u64i
 //  CIR-NEXT:   cir.libc.memcpy %[[#SIZE]] bytes from %[[#SRC_VOID_PTR]] to %[[#DST_VOID_PTR]] : !u64i, !cir.ptr<!void> -> !cir.ptr<!void>
 //       CIR: }
@@ -87,7 +87,7 @@ two_ints test_scalar_to_aggregate(unsigned long ul) {
 
 // CIR-LABEL: cir.func @_Z24test_scalar_to_aggregatem
 //       CIR:   %[[#SRC_VOID_PTR:]] = cir.cast(bitcast, %{{.+}} : !cir.ptr<!u64i>), !cir.ptr<!void>
-//  CIR-NEXT:   %[[#DST_VOID_PTR:]] = cir.cast(bitcast, %{{.+}} : !cir.ptr<!ty_22two_ints22>), !cir.ptr<!void>
+//  CIR-NEXT:   %[[#DST_VOID_PTR:]] = cir.cast(bitcast, %{{.+}} : !cir.ptr<!ty_two_ints>), !cir.ptr<!void>
 //  CIR-NEXT:   %[[#SIZE:]] = cir.const #cir.int<8> : !u64i
 //  CIR-NEXT:   cir.libc.memcpy %[[#SIZE]] bytes from %[[#SRC_VOID_PTR]] to %[[#DST_VOID_PTR]] : !u64i, !cir.ptr<!void> -> !cir.ptr<!void>
 //       CIR: }
@@ -123,7 +123,7 @@ two_ints test_rvalue_aggregate() {
 //  CIR-NEXT:     %[[#A:]] = cir.const #cir.int<42> : !u64i
 //  CIR-NEXT:     cir.store %[[#A]], %[[#TMP_SLOT]] : !u64i, !cir.ptr<!u64i>
 //  CIR-NEXT:     %[[#SRC_VOID_PTR:]] = cir.cast(bitcast, %[[#TMP_SLOT]] : !cir.ptr<!u64i>), !cir.ptr<!void>
-//  CIR-NEXT:     %[[#DST_VOID_PTR:]] = cir.cast(bitcast, %0 : !cir.ptr<!ty_22two_ints22>), !cir.ptr<!void>
+//  CIR-NEXT:     %[[#DST_VOID_PTR:]] = cir.cast(bitcast, %0 : !cir.ptr<!ty_two_ints>), !cir.ptr<!void>
 //  CIR-NEXT:     %[[#SIZE:]] = cir.const #cir.int<8> : !u64i
 //  CIR-NEXT:     cir.libc.memcpy %[[#SIZE]] bytes from %[[#SRC_VOID_PTR]] to %[[#DST_VOID_PTR]] : !u64i, !cir.ptr<!void> -> !cir.ptr<!void>
 //  CIR-NEXT:   }
diff --git a/clang/test/CIR/CodeGen/call-via-class-member-funcptr.cpp b/clang/test/CIR/CodeGen/call-via-class-member-funcptr.cpp
index c1e678be8635..a69ca1a19c96 100644
--- a/clang/test/CIR/CodeGen/call-via-class-member-funcptr.cpp
+++ b/clang/test/CIR/CodeGen/call-via-class-member-funcptr.cpp
@@ -16,13 +16,13 @@ class f {
 const char *f::b() { return g.b(h); }
 void fn1() { f f1; }
 
-// CIR: ty_22a22 = !cir.struct<class "a" {!cir.int<u, 8>} #cir.record.decl.ast>
-// CIR: ty_22f22 = !cir.struct<class "f" {!cir.struct<class "a" {!cir.int<u, 8>} #cir.record.decl.ast>}>
+// CIR: ty_a = !cir.struct<class "a" {!cir.int<u, 8>} #cir.record.decl.ast>
+// CIR: ty_f = !cir.struct<class "f" {!cir.struct<class "a" {!cir.int<u, 8>} #cir.record.decl.ast>}>
 
 // CIR: cir.global external @h = #cir.int<0>
 // CIR: cir.func private @_ZN1a1bEi(!s32i) -> !cir.ptr<!s8i>
 
-// CIR: cir.func @_ZN1f1bEv(%arg0: !cir.ptr<!ty_22f22> loc{{.*}}) -> !cir.ptr<!s8i>
+// CIR: cir.func @_ZN1f1bEv(%arg0: !cir.ptr<!ty_f> loc{{.*}}) -> !cir.ptr<!s8i>
 // CIR: [[H_PTR:%.*]] = cir.get_global @h : !cir.ptr<!s32i> loc(#loc18)
 // CIR: [[H_VAL:%.*]] = cir.load [[H_PTR]] : !cir.ptr<!s32i>, !s32i
 // CIR: [[RET1_VAL:%.*]] = cir.call @_ZN1a1bEi([[H_VAL]]) : (!s32i) -> !cir.ptr<!s8i>
@@ -32,7 +32,7 @@ void fn1() { f f1; }
 // CIR: cir.return [[RET1_VAL2]] : !cir.ptr<!s8i>
 
 // CIR: cir.func @_Z3fn1v()
-// CIR: [[CLS_F:%.*]] = cir.alloca !ty_22f22, !cir.ptr<!ty_22f22>, ["f1"] {alignment = 1 : i64}
+// CIR: [[CLS_F:%.*]] = cir.alloca !ty_f, !cir.ptr<!ty_f>, ["f1"] {alignment = 1 : i64}
 // CIR: cir.return
 
 // LLVM: %class.f = type { %class.a }
diff --git a/clang/test/CIR/CodeGen/cast.c b/clang/test/CIR/CodeGen/cast.c
index 4490910cad43..710b065f8087 100644
--- a/clang/test/CIR/CodeGen/cast.c
+++ b/clang/test/CIR/CodeGen/cast.c
@@ -8,11 +8,11 @@ int cstyle_cast_lvalue(A a) {
   return ((A)(a)).x;
 }
 
-// CHECK:  cir.func @cstyle_cast_lvalue(%arg0: !ty_22A22 loc({{.*}}))
-// CHECK:    [[ALLOC_A:%.*]] = cir.alloca !ty_22A22, !cir.ptr<!ty_22A22>, ["a", init] {alignment = 4 : i64}
+// CHECK:  cir.func @cstyle_cast_lvalue(%arg0: !ty_A loc({{.*}}))
+// CHECK:    [[ALLOC_A:%.*]] = cir.alloca !ty_A, !cir.ptr<!ty_A>, ["a", init] {alignment = 4 : i64}
 // CHECK:    [[ALLOC_RET:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
-// CHECK:    cir.store %arg0, [[ALLOC_A]] : !ty_22A22, !cir.ptr<!ty_22A22>
-// CHECK:    [[X_ADDR:%.*]] = cir.get_member [[ALLOC_A]][0] {name = "x"} : !cir.ptr<!ty_22A22> -> !cir.ptr<!s32i>
+// CHECK:    cir.store %arg0, [[ALLOC_A]] : !ty_A, !cir.ptr<!ty_A>
+// CHECK:    [[X_ADDR:%.*]] = cir.get_member [[ALLOC_A]][0] {name = "x"} : !cir.ptr<!ty_A> -> !cir.ptr<!s32i>
 // CHECK:    [[X:%.*]] = cir.load [[X_ADDR]] : !cir.ptr<!s32i>, !s32i
 // CHECK:    cir.store [[X]], [[ALLOC_RET]] : !s32i, !cir.ptr<!s32i>
 // CHECK:    [[RET:%.*]] = cir.load [[ALLOC_RET]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/CodeGen/cast.cpp b/clang/test/CIR/CodeGen/cast.cpp
index 15991a8f1fd3..b5d1d8e4f43f 100644
--- a/clang/test/CIR/CodeGen/cast.cpp
+++ b/clang/test/CIR/CodeGen/cast.cpp
@@ -129,8 +129,8 @@ void null_cast(long ptr) {
 // CHECK: cir.func @_Z9null_castl
 // CHECK:   %[[ADDR:[0-9]+]] = cir.const #cir.ptr<null> : !cir.ptr<!s32i>
 // CHECK:   cir.store %{{[0-9]+}}, %[[ADDR]] : !s32i, !cir.ptr<!s32i>
-// CHECK:   %[[BASE:[0-9]+]] = cir.const #cir.ptr<null> : !cir.ptr<!ty_22A22>
-// CHECK:   %[[FIELD:[0-9]+]] = cir.get_member %[[BASE]][0] {name = "x"} : !cir.ptr<!ty_22A22> -> !cir.ptr<!s32i>
+// CHECK:   %[[BASE:[0-9]+]] = cir.const #cir.ptr<null> : !cir.ptr<!ty_A>
+// CHECK:   %[[FIELD:[0-9]+]] = cir.get_member %[[BASE]][0] {name = "x"} : !cir.ptr<!ty_A> -> !cir.ptr<!s32i>
 // CHECK:   cir.store %{{[0-9]+}}, %[[FIELD]] : !s32i, !cir.ptr<!s32i>
 
 void int_cast(long ptr) {
@@ -138,7 +138,7 @@ void int_cast(long ptr) {
 }
 
 // CHECK: cir.func @_Z8int_castl
-// CHECK:   %[[BASE:[0-9]+]] = cir.cast(int_to_ptr, %{{[0-9]+}} : !u64i), !cir.ptr<!ty_22A22>
-// CHECK:   %[[FIELD:[0-9]+]] = cir.get_member %[[BASE]][0] {name = "x"} : !cir.ptr<!ty_22A22> -> !cir.ptr<!s32i>
+// CHECK:   %[[BASE:[0-9]+]] = cir.cast(int_to_ptr, %{{[0-9]+}} : !u64i), !cir.ptr<!ty_A>
+// CHECK:   %[[FIELD:[0-9]+]] = cir.get_member %[[BASE]][0] {name = "x"} : !cir.ptr<!ty_A> -> !cir.ptr<!s32i>
 // CHECK:   cir.store %{{[0-9]+}}, %[[FIELD]] : !s32i, !cir.ptr<!s32i>
 
diff --git a/clang/test/CIR/CodeGen/compound-literal.c b/clang/test/CIR/CodeGen/compound-literal.c
index f0ee805dda44..74669589d084 100644
--- a/clang/test/CIR/CodeGen/compound-literal.c
+++ b/clang/test/CIR/CodeGen/compound-literal.c
@@ -13,7 +13,7 @@ S a = {
 };
 
 // CIR: cir.global "private" internal @".compoundLiteral.0" = #cir.zero : !cir.array<!s32i x 0> {alignment = 4 : i64}
-// CIR: cir.global external @a = #cir.const_struct<{#cir.global_view<@".compoundLiteral.0"> : !cir.ptr<!s32i>}> : !ty_22S22
+// CIR: cir.global external @a = #cir.const_struct<{#cir.global_view<@".compoundLiteral.0"> : !cir.ptr<!s32i>}> : !ty_S
 
 // LLVM: @.compoundLiteral.0 = internal global [0 x i32] zeroinitializer
 // LLVM: @a = global %struct.S { ptr @.compoundLiteral.0 }
@@ -23,7 +23,7 @@ S b = {
 };
 
 // CIR: cir.global "private" internal @".compoundLiteral.1" = #cir.const_array<[#cir.int<1> : !s32i]> : !cir.array<!s32i x 1> {alignment = 4 : i64}
-// CIR: cir.global external @b = #cir.const_struct<{#cir.global_view<@".compoundLiteral.1"> : !cir.ptr<!s32i>}> : !ty_22S22
+// CIR: cir.global external @b = #cir.const_struct<{#cir.global_view<@".compoundLiteral.1"> : !cir.ptr<!s32i>}> : !ty_S
 
 // LLVM: @.compoundLiteral.1 = internal global [1 x i32] [i32 1]
 // LLVM: @b = global %struct.S { ptr @.compoundLiteral.1 }
@@ -37,8 +37,8 @@ int foo() {
 
 // CIR:  cir.func no_proto @foo() -> !s32i
 // CIR:    [[RET_MEM:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
-// CIR:    [[COMPLITERAL_MEM:%.*]] = cir.alloca !ty_22anon2E122, !cir.ptr<!ty_22anon2E122>, [".compoundliteral"] {alignment = 4 : i64}
-// CIR:    [[FIELD:%.*]] = cir.get_member [[COMPLITERAL_MEM]][0] {name = "i"} : !cir.ptr<!ty_22anon2E122> -> !cir.ptr<!s32i>
+// CIR:    [[COMPLITERAL_MEM:%.*]] = cir.alloca !ty_anon2E1_, !cir.ptr<!ty_anon2E1_>, [".compoundliteral"] {alignment = 4 : i64}
+// CIR:    [[FIELD:%.*]] = cir.get_member [[COMPLITERAL_MEM]][0] {name = "i"} : !cir.ptr<!ty_anon2E1_> -> !cir.ptr<!s32i>
 // CIR:    [[ONE:%.*]] = cir.const #cir.int<1> : !s32i
 // CIR:    cir.store [[ONE]], [[FIELD]] : !s32i, !cir.ptr<!s32i>
 // CIR:    [[ONE:%.*]] = cir.const #cir.int<1> : !s32i
@@ -52,7 +52,7 @@ struct G g(int x, int y, int z) {
 }
 
 // CIR:  cir.func @g
-// CIR:    %[[RETVAL:.*]] = cir.alloca !ty_22G22, !cir.ptr<!ty_22G22>, ["__retval"] {alignment = 2 : i64}
+// CIR:    %[[RETVAL:.*]] = cir.alloca !ty_G, !cir.ptr<!ty_G>, ["__retval"] {alignment = 2 : i64}
 // CIR:    %[[X:.*]] = cir.get_member %[[RETVAL]][0] {name = "x"}
 // CIR:    cir.store {{.*}}, %[[X]] : !s16i
 // CIR:    %[[Y:.*]] = cir.get_member %[[RETVAL]][1] {name = "y"}
@@ -74,21 +74,21 @@ void split_large_page(unsigned long addr, pgprot_t prot)
 
 // CIR-LABEL: @split_large_page
 // CIR:   %[[VAL_2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["addr", init] {alignment = 8 : i64}
-// CIR:   %[[VAL_3:.*]] = cir.alloca !ty_22pgprot_t22, !cir.ptr<!ty_22pgprot_t22>, ["prot", init] {alignment = 8 : i64}
-// CIR:   %[[VAL_4:.*]] = cir.alloca !ty_22pgprot_t22, !cir.ptr<!ty_22pgprot_t22>, ["tmp"] {alignment = 8 : i64}
+// CIR:   %[[VAL_3:.*]] = cir.alloca !ty_pgprot_t, !cir.ptr<!ty_pgprot_t>, ["prot", init] {alignment = 8 : i64}
+// CIR:   %[[VAL_4:.*]] = cir.alloca !ty_pgprot_t, !cir.ptr<!ty_pgprot_t>, ["tmp"] {alignment = 8 : i64}
 // CIR:   cir.store {{.*}}, %[[VAL_2]] : !u64i, !cir.ptr<!u64i>
-// CIR:   cir.store {{.*}}, %[[VAL_3]] : !ty_22pgprot_t22, !cir.ptr<!ty_22pgprot_t22>
+// CIR:   cir.store {{.*}}, %[[VAL_3]] : !ty_pgprot_t, !cir.ptr<!ty_pgprot_t>
 // CIR:   %[[VAL_5:.*]] = cir.load %[[VAL_2]] : !cir.ptr<!u64i>, !u64i
 // CIR:   %[[VAL_6:.*]] = cir.cast(int_to_bool, %[[VAL_5]] : !u64i), !cir.bool
 // CIR:   cir.if %[[VAL_6]] {
-// CIR:     cir.copy %[[VAL_3]] to %[[VAL_4]] : !cir.ptr<!ty_22pgprot_t22>
+// CIR:     cir.copy %[[VAL_3]] to %[[VAL_4]] : !cir.ptr<!ty_pgprot_t>
 // CIR:   } else {
-// CIR:     %[[VAL_7:.*]] = cir.get_member %[[VAL_4]][0] {name = "pgprot"} : !cir.ptr<!ty_22pgprot_t22> -> !cir.ptr<!u64i>
+// CIR:     %[[VAL_7:.*]] = cir.get_member %[[VAL_4]][0] {name = "pgprot"} : !cir.ptr<!ty_pgprot_t> -> !cir.ptr<!u64i>
 // CIR:     %[[VAL_8:.*]] = cir.const #cir.int<1> : !s32i
 // CIR:     %[[VAL_9:.*]] = cir.cast(integral, %[[VAL_8]] : !s32i), !u64i
 // CIR:     cir.store %[[VAL_9]], %[[VAL_7]] : !u64i, !cir.ptr<!u64i>
 // CIR:   }
-// CIR:   %[[VAL_10:.*]] = cir.get_member %[[VAL_4]][0] {name = "pgprot"} : !cir.ptr<!ty_22pgprot_t22> -> !cir.ptr<!u64i>
+// CIR:   %[[VAL_10:.*]] = cir.get_member %[[VAL_4]][0] {name = "pgprot"} : !cir.ptr<!ty_pgprot_t> -> !cir.ptr<!u64i>
 // CIR:   %[[VAL_11:.*]] = cir.load %[[VAL_10]] : !cir.ptr<!u64i>, !u64i
 // CIR:   cir.return
 // CIR: }
diff --git a/clang/test/CIR/CodeGen/cond.cpp b/clang/test/CIR/CodeGen/cond.cpp
index f2c063eb574b..e00ee528a72d 100644
--- a/clang/test/CIR/CodeGen/cond.cpp
+++ b/clang/test/CIR/CodeGen/cond.cpp
@@ -17,11 +17,11 @@ min(const unsigned long& __a, const unsigned long& __b) {
 // CHECK:   cir.store %arg0, %0 : !cir.ptr<!u64i>, !cir.ptr<!cir.ptr<!u64i>>
 // CHECK:   cir.store %arg1, %1 : !cir.ptr<!u64i>, !cir.ptr<!cir.ptr<!u64i>>
 // CHECK:   cir.scope {
-// CHECK:     %4 = cir.alloca !ty_22__less22, !cir.ptr<!ty_22__less22>, ["ref.tmp0"] {alignment = 1 : i64}
-// CHECK:     cir.call @_ZN6__lessC1Ev(%4) : (!cir.ptr<!ty_22__less22>) -> ()
+// CHECK:     %4 = cir.alloca !ty___less, !cir.ptr<!ty___less>, ["ref.tmp0"] {alignment = 1 : i64}
+// CHECK:     cir.call @_ZN6__lessC1Ev(%4) : (!cir.ptr<!ty___less>) -> ()
 // CHECK:     %5 = cir.load %1 : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
 // CHECK:     %6 = cir.load %0 : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
-// CHECK:     %7 = cir.call @_ZNK6__lessclERKmS1_(%4, %5, %6) : (!cir.ptr<!ty_22__less22>, !cir.ptr<!u64i>, !cir.ptr<!u64i>) -> !cir.bool
+// CHECK:     %7 = cir.call @_ZNK6__lessclERKmS1_(%4, %5, %6) : (!cir.ptr<!ty___less>, !cir.ptr<!u64i>, !cir.ptr<!u64i>) -> !cir.bool
 // CHECK:     %8 = cir.ternary(%7, true {
 // CHECK:       %9 = cir.load %1 : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
 // CHECK:       cir.yield %9 : !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGen/const-bitfields.c b/clang/test/CIR/CodeGen/const-bitfields.c
index fc1b6cd07274..b58db7f193a2 100644
--- a/clang/test/CIR/CodeGen/const-bitfields.c
+++ b/clang/test/CIR/CodeGen/const-bitfields.c
@@ -15,7 +15,7 @@ struct Inner {
 };
 
 // CHECK: !ty_anon_struct = !cir.struct<struct  {!cir.int<u, 8>, !cir.int<u, 8>, !cir.int<u, 8>, !cir.int<s, 32>}>
-// CHECK: !ty_22T22 = !cir.struct<struct "T" {!cir.array<!cir.int<u, 8> x 3>, !cir.int<s, 32>} #cir.record.decl.ast>
+// CHECK: !ty_T = !cir.struct<struct "T" {!cir.array<!cir.int<u, 8> x 3>, !cir.int<s, 32>} #cir.record.decl.ast>
 // CHECK: !ty_anon_struct1 = !cir.struct<struct  {!cir.int<u, 8>, !cir.array<!cir.int<u, 8> x 3>, !cir.int<u, 8>, !cir.int<u, 8>, !cir.int<u, 8>, !cir.int<u, 8>}>
 // CHECK: #bfi_Z = #cir.bitfield_info<name = "Z", storage_type = !cir.array<!u8i x 3>, size = 9, offset = 11, is_signed = true>
 
@@ -29,8 +29,8 @@ struct Inner var = { 1, 0, 1, 21};
 
 // CHECK: cir.func {{.*@getZ()}}
 // CHECK:   %1 = cir.get_global @GV : !cir.ptr<!ty_anon_struct>
-// CHECK:   %2 = cir.cast(bitcast, %1 : !cir.ptr<!ty_anon_struct>), !cir.ptr<!ty_22T22>
-// CHECK:   %3 = cir.cast(bitcast, %2 : !cir.ptr<!ty_22T22>), !cir.ptr<!cir.array<!u8i x 3>>
+// CHECK:   %2 = cir.cast(bitcast, %1 : !cir.ptr<!ty_anon_struct>), !cir.ptr<!ty_T>
+// CHECK:   %3 = cir.cast(bitcast, %2 : !cir.ptr<!ty_T>), !cir.ptr<!cir.array<!u8i x 3>>
 // CHECK:   %4 = cir.get_bitfield(#bfi_Z, %3 : !cir.ptr<!cir.array<!u8i x 3>>) -> !s32i
 int getZ() {
   return GV.Z;
@@ -39,8 +39,8 @@ int getZ() {
 // check the type used is the type of T struct for plain field
 // CHECK:  cir.func {{.*@getW()}}
 // CHECK:    %1 = cir.get_global @GV : !cir.ptr<!ty_anon_struct>
-// CHECK:    %2 = cir.cast(bitcast, %1 : !cir.ptr<!ty_anon_struct>), !cir.ptr<!ty_22T22>
-// CHECK:    %3 = cir.get_member %2[1] {name = "W"} : !cir.ptr<!ty_22T22> -> !cir.ptr<!s32i>
+// CHECK:    %2 = cir.cast(bitcast, %1 : !cir.ptr<!ty_anon_struct>), !cir.ptr<!ty_T>
+// CHECK:    %3 = cir.get_member %2[1] {name = "W"} : !cir.ptr<!ty_T> -> !cir.ptr<!s32i>
 int getW() {
   return GV.W;
 }
diff --git a/clang/test/CIR/CodeGen/coro-task.cpp b/clang/test/CIR/CodeGen/coro-task.cpp
index b879b0953ad7..50505f7b9b66 100644
--- a/clang/test/CIR/CodeGen/coro-task.cpp
+++ b/clang/test/CIR/CodeGen/coro-task.cpp
@@ -135,7 +135,7 @@ co_invoke_fn co_invoke;
 // CHECK-DAG: ![[SuspendAlways:.*]] = !cir.struct<struct "std::suspend_always" {!cir.int<u, 8>}>
 
 // CHECK: module {{.*}} {
-// CHECK-NEXT: cir.global external @_ZN5folly4coro9co_invokeE = #cir.zero : !ty_22folly3A3Acoro3A3Aco_invoke_fn22
+// CHECK-NEXT: cir.global external @_ZN5folly4coro9co_invokeE = #cir.zero : !ty_folly3A3Acoro3A3Aco_invoke_fn
 
 // CHECK: cir.func builtin private @__builtin_coro_id(!u32i, !cir.ptr<!void>, !cir.ptr<!void>, !cir.ptr<!void>) -> !u32i
 // CHECK: cir.func builtin private @__builtin_coro_alloc(!u32i) -> !cir.bool
@@ -274,7 +274,7 @@ folly::coro::Task<int> byRef(const std::string& s) {
 }
 
 // FIXME: this could be less redundant than two allocas + reloads
-// CHECK: cir.func coroutine @_Z5byRefRKSt6string(%arg0: !cir.ptr<![[StdString]]> {{.*}}22 extra{{.*}}{
+// CHECK: cir.func coroutine @_Z5byRefRKSt6string(%arg0: !cir.ptr<![[StdString]]> {{.*}} ![[IntTask]] extra{{.*}}{
 // CHECK: %[[#AllocaParam:]] = cir.alloca !cir.ptr<![[StdString]]>, {{.*}} ["s", init]
 // CHECK: %[[#AllocaFnUse:]] = cir.alloca !cir.ptr<![[StdString]]>, {{.*}} ["s", init]
 
@@ -291,7 +291,7 @@ folly::coro::Task<void> silly_coro() {
 // Make sure we properly handle OnFallthrough coro body sub stmt and
 // check there are not multiple co_returns emitted.
 
-// CHECK: cir.func coroutine @_Z10silly_corov() {{.*}}22 extra{{.*}}{
+// CHECK: cir.func coroutine @_Z10silly_corov() {{.*}} ![[VoidTask]] extra{{.*}}{
 // CHECK: cir.await(init, ready : {
 // CHECK: cir.call @_ZN5folly4coro4TaskIvE12promise_type11return_voidEv
 // CHECK-NOT: cir.call @_ZN5folly4coro4TaskIvE12promise_type11return_voidEv
@@ -303,7 +303,7 @@ folly::coro::Task<int> go1() {
   co_return co_await task;
 }
 
-// CHECK: cir.func coroutine @_Z3go1v() {{.*}}22 extra{{.*}}{
+// CHECK: cir.func coroutine @_Z3go1v() {{.*}} ![[IntTask]] extra{{.*}}{
 // CHECK: %[[#IntTaskAddr:]] = cir.alloca ![[IntTask]], !cir.ptr<![[IntTask]]>, ["task", init]
 
 // CHECK:   cir.await(init, ready : {
@@ -338,8 +338,8 @@ folly::coro::Task<int> go1_lambda() {
   co_return co_await task;
 }
 
-// CHECK: cir.func coroutine lambda internal private @_ZZ10go1_lambdavENK3$_0clEv{{.*}}22 extra{{.*}}{
-// CHECK: cir.func coroutine @_Z10go1_lambdav() {{.*}}22 extra{{.*}}{
+// CHECK: cir.func coroutine lambda internal private @_ZZ10go1_lambdavENK3$_0clEv{{.*}} ![[IntTask]] extra{{.*}}{
+// CHECK: cir.func coroutine @_Z10go1_lambdav() {{.*}} ![[IntTask]] extra{{.*}}{
 
 folly::coro::Task<int> go4() {
   auto* fn = +[](int const& i) -> folly::coro::Task<int> { co_return i; };
@@ -347,7 +347,7 @@ folly::coro::Task<int> go4() {
   co_return co_await std::move(task);
 }
 
-// CHECK: cir.func coroutine @_Z3go4v() {{.*}}22 extra{{.*}}{
+// CHECK: cir.func coroutine @_Z3go4v() {{.*}} ![[IntTask]] extra{{.*}}{
 
 // CHECK:   cir.await(init, ready : {
 // CHECK:   }, suspend : {
@@ -356,10 +356,10 @@ folly::coro::Task<int> go4() {
 // CHECK: }
 
 // CHECK: %12 = cir.scope {
-// CHECK:   %17 = cir.alloca !ty_22anon2E522, !cir.ptr<!ty_22anon2E522>, ["ref.tmp1"] {alignment = 1 : i64}
+// CHECK:   %17 = cir.alloca !ty_anon2E5_, !cir.ptr<!ty_anon2E5_>, ["ref.tmp1"] {alignment = 1 : i64}
 
 // Get the lambda invoker ptr via `lambda operator folly::coro::Task<int> (*)(int const&)()`
-// CHECK:   %18 = cir.call @_ZZ3go4vENK3$_0cvPFN5folly4coro4TaskIiEERKiEEv(%17) : (!cir.ptr<!ty_22anon2E522>) -> !cir.ptr<!cir.func<![[IntTask]] (!cir.ptr<!s32i>)>>
+// CHECK:   %18 = cir.call @_ZZ3go4vENK3$_0cvPFN5folly4coro4TaskIiEERKiEEv(%17) : (!cir.ptr<!ty_anon2E5_>) -> !cir.ptr<!cir.func<![[IntTask]] (!cir.ptr<!s32i>)>>
 // CHECK:   %19 = cir.unary(plus, %18) : !cir.ptr<!cir.func<![[IntTask]] (!cir.ptr<!s32i>)>>, !cir.ptr<!cir.func<![[IntTask]] (!cir.ptr<!s32i>)>>
 // CHECK:   cir.yield %19 : !cir.ptr<!cir.func<![[IntTask]] (!cir.ptr<!s32i>)>>
 // CHECK: }
@@ -387,7 +387,7 @@ folly::coro::Task<void> yield1() {
   co_yield t;
 }
 
-// CHECK: cir.func coroutine @_Z6yield1v() -> !ty_22folly3A3Acoro3A3ATask3Cvoid3E22
+// CHECK: cir.func coroutine @_Z6yield1v() -> !ty_folly3A3Acoro3A3ATask3Cvoid3E
 
 // CHECK: cir.await(init, ready : {
 // CHECK: }, suspend : {
@@ -395,30 +395,30 @@ folly::coro::Task<void> yield1() {
 // CHECK: },)
 
 //      CHECK: cir.scope {
-// CHECK-NEXT:   %[[#SUSPEND_PTR:]] = cir.alloca !ty_22std3A3Asuspend_always22, !cir.ptr<!ty_22std3A3Asuspend_always22>
-// CHECK-NEXT:   %[[#AWAITER_PTR:]] = cir.alloca !ty_22folly3A3Acoro3A3ATask3Cvoid3E22, !cir.ptr<!ty_22folly3A3Acoro3A3ATask3Cvoid3E22>
-// CHECK-NEXT:   %[[#CORO_PTR:]] = cir.alloca !ty_22std3A3Acoroutine_handle3Cvoid3E22, !cir.ptr<!ty_22std3A3Acoroutine_handle3Cvoid3E22>
-// CHECK-NEXT:   %[[#CORO2_PTR:]] = cir.alloca !ty_22std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E22, !cir.ptr<!ty_22std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E22>
-// CHECK-NEXT:   cir.call @_ZN5folly4coro4TaskIvEC1ERKS2_(%[[#AWAITER_PTR]], %{{.+}}) : (!cir.ptr<!ty_22folly3A3Acoro3A3ATask3Cvoid3E22>, !cir.ptr<!ty_22folly3A3Acoro3A3ATask3Cvoid3E22>) -> ()
-// CHECK-NEXT:   %[[#AWAITER:]] = cir.load %[[#AWAITER_PTR]] : !cir.ptr<!ty_22folly3A3Acoro3A3ATask3Cvoid3E22>, !ty_22folly3A3Acoro3A3ATask3Cvoid3E22
-// CHECK-NEXT:   %[[#SUSPEND:]] = cir.call @_ZN5folly4coro4TaskIvE12promise_type11yield_valueES2_(%{{.+}}, %[[#AWAITER]]) : (!cir.ptr<!ty_22folly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type22>, !ty_22folly3A3Acoro3A3ATask3Cvoid3E22) -> !ty_22std3A3Asuspend_always22
-// CHECK-NEXT:   cir.store %[[#SUSPEND]], %[[#SUSPEND_PTR]] : !ty_22std3A3Asuspend_always22, !cir.ptr<!ty_22std3A3Asuspend_always22>
+// CHECK-NEXT:   %[[#SUSPEND_PTR:]] = cir.alloca !ty_std3A3Asuspend_always, !cir.ptr<!ty_std3A3Asuspend_always>
+// CHECK-NEXT:   %[[#AWAITER_PTR:]] = cir.alloca !ty_folly3A3Acoro3A3ATask3Cvoid3E, !cir.ptr<!ty_folly3A3Acoro3A3ATask3Cvoid3E>
+// CHECK-NEXT:   %[[#CORO_PTR:]] = cir.alloca !ty_std3A3Acoroutine_handle3Cvoid3E, !cir.ptr<!ty_std3A3Acoroutine_handle3Cvoid3E>
+// CHECK-NEXT:   %[[#CORO2_PTR:]] = cir.alloca !ty_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E, !cir.ptr<!ty_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E>
+// CHECK-NEXT:   cir.call @_ZN5folly4coro4TaskIvEC1ERKS2_(%[[#AWAITER_PTR]], %{{.+}}) : (!cir.ptr<!ty_folly3A3Acoro3A3ATask3Cvoid3E>, !cir.ptr<!ty_folly3A3Acoro3A3ATask3Cvoid3E>) -> ()
+// CHECK-NEXT:   %[[#AWAITER:]] = cir.load %[[#AWAITER_PTR]] : !cir.ptr<!ty_folly3A3Acoro3A3ATask3Cvoid3E>, !ty_folly3A3Acoro3A3ATask3Cvoid3E
+// CHECK-NEXT:   %[[#SUSPEND:]] = cir.call @_ZN5folly4coro4TaskIvE12promise_type11yield_valueES2_(%{{.+}}, %[[#AWAITER]]) : (!cir.ptr<!ty_folly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type>, !ty_folly3A3Acoro3A3ATask3Cvoid3E) -> !ty_std3A3Asuspend_always
+// CHECK-NEXT:   cir.store %[[#SUSPEND]], %[[#SUSPEND_PTR]] : !ty_std3A3Asuspend_always, !cir.ptr<!ty_std3A3Asuspend_always>
 // CHECK-NEXT:   cir.await(yield, ready : {
 // CHECK-NEXT:     %[[#READY:]] = cir.scope {
-// CHECK-NEXT:       %[[#A:]] = cir.call @_ZNSt14suspend_always11await_readyEv(%[[#SUSPEND_PTR]]) : (!cir.ptr<!ty_22std3A3Asuspend_always22>) -> !cir.bool
+// CHECK-NEXT:       %[[#A:]] = cir.call @_ZNSt14suspend_always11await_readyEv(%[[#SUSPEND_PTR]]) : (!cir.ptr<!ty_std3A3Asuspend_always>) -> !cir.bool
 // CHECK-NEXT:       cir.yield %[[#A]] : !cir.bool
 // CHECK-NEXT:     } : !cir.bool
 // CHECK-NEXT:     cir.condition(%[[#READY]])
 // CHECK-NEXT:   }, suspend : {
-// CHECK-NEXT:     %[[#CORO2:]] = cir.call @_ZNSt16coroutine_handleIN5folly4coro4TaskIvE12promise_typeEE12from_addressEPv(%9) : (!cir.ptr<!void>) -> !ty_22std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E22
-// CHECK-NEXT:     cir.store %[[#CORO2]], %[[#CORO2_PTR]] : !ty_22std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E22, !cir.ptr<!ty_22std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E22>
-// CHECK-NEXT:     %[[#B:]] = cir.load %[[#CORO2_PTR]] : !cir.ptr<!ty_22std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E22>, !ty_22std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E22
-// CHECK-NEXT:     cir.call @_ZNSt16coroutine_handleIvEC1IN5folly4coro4TaskIvE12promise_typeEEES_IT_E(%[[#CORO_PTR]], %[[#B]]) : (!cir.ptr<!ty_22std3A3Acoroutine_handle3Cvoid3E22>, !ty_22std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E22) -> ()
-// CHECK-NEXT:     %[[#C:]] = cir.load %[[#CORO_PTR]] : !cir.ptr<!ty_22std3A3Acoroutine_handle3Cvoid3E22>, !ty_22std3A3Acoroutine_handle3Cvoid3E22
-// CHECK-NEXT:     cir.call @_ZNSt14suspend_always13await_suspendESt16coroutine_handleIvE(%[[#SUSPEND_PTR]], %[[#C]]) : (!cir.ptr<!ty_22std3A3Asuspend_always22>, !ty_22std3A3Acoroutine_handle3Cvoid3E22) -> ()
+// CHECK-NEXT:     %[[#CORO2:]] = cir.call @_ZNSt16coroutine_handleIN5folly4coro4TaskIvE12promise_typeEE12from_addressEPv(%9) : (!cir.ptr<!void>) -> !ty_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E
+// CHECK-NEXT:     cir.store %[[#CORO2]], %[[#CORO2_PTR]] : !ty_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E, !cir.ptr<!ty_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E>
+// CHECK-NEXT:     %[[#B:]] = cir.load %[[#CORO2_PTR]] : !cir.ptr<!ty_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E>, !ty_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E
+// CHECK-NEXT:     cir.call @_ZNSt16coroutine_handleIvEC1IN5folly4coro4TaskIvE12promise_typeEEES_IT_E(%[[#CORO_PTR]], %[[#B]]) : (!cir.ptr<!ty_std3A3Acoroutine_handle3Cvoid3E>, !ty_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E) -> ()
+// CHECK-NEXT:     %[[#C:]] = cir.load %[[#CORO_PTR]] : !cir.ptr<!ty_std3A3Acoroutine_handle3Cvoid3E>, !ty_std3A3Acoroutine_handle3Cvoid3E
+// CHECK-NEXT:     cir.call @_ZNSt14suspend_always13await_suspendESt16coroutine_handleIvE(%[[#SUSPEND_PTR]], %[[#C]]) : (!cir.ptr<!ty_std3A3Asuspend_always>, !ty_std3A3Acoroutine_handle3Cvoid3E) -> ()
 // CHECK-NEXT:     cir.yield
 // CHECK-NEXT:   }, resume : {
-// CHECK-NEXT:     cir.call @_ZNSt14suspend_always12await_resumeEv(%[[#SUSPEND_PTR]]) : (!cir.ptr<!ty_22std3A3Asuspend_always22>) -> ()
+// CHECK-NEXT:     cir.call @_ZNSt14suspend_always12await_resumeEv(%[[#SUSPEND_PTR]]) : (!cir.ptr<!ty_std3A3Asuspend_always>) -> ()
 // CHECK-NEXT:     cir.yield
 // CHECK-NEXT:   },)
 // CHECK-NEXT: }
diff --git a/clang/test/CIR/CodeGen/ctor-alias.cpp b/clang/test/CIR/CodeGen/ctor-alias.cpp
index 6476659ef41f..3739ecef1cce 100644
--- a/clang/test/CIR/CodeGen/ctor-alias.cpp
+++ b/clang/test/CIR/CodeGen/ctor-alias.cpp
@@ -9,20 +9,20 @@ void t() {
 }
 
 //      CHECK: cir.func linkonce_odr @_ZN11DummyStringC2EPKc
-// CHECK-NEXT:     %0 = cir.alloca !cir.ptr<!ty_22DummyString22>, !cir.ptr<!cir.ptr<!ty_22DummyString22>>, ["this", init] {alignment = 8 : i64}
+// CHECK-NEXT:     %0 = cir.alloca !cir.ptr<!ty_DummyString>, !cir.ptr<!cir.ptr<!ty_DummyString>>, ["this", init] {alignment = 8 : i64}
 // CHECK-NEXT:     %1 = cir.alloca !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>, ["s", init] {alignment = 8 : i64}
-// CHECK-NEXT:     cir.store %arg0, %0 : !cir.ptr<!ty_22DummyString22>, !cir.ptr<!cir.ptr<!ty_22DummyString22>>
+// CHECK-NEXT:     cir.store %arg0, %0 : !cir.ptr<!ty_DummyString>, !cir.ptr<!cir.ptr<!ty_DummyString>>
 // CHECK-NEXT:     cir.store %arg1, %1 : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
-// CHECK-NEXT:     %2 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22DummyString22>>, !cir.ptr<!ty_22DummyString22>
+// CHECK-NEXT:     %2 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_DummyString>>, !cir.ptr<!ty_DummyString>
 // CHECK-NEXT:     cir.return
 
 // CHECK-NOT: cir.fun @_ZN11DummyStringC1EPKc
 
 //      CHECK:   cir.func @_Z1tv
-// CHECK-NEXT:     %0 = cir.alloca !ty_22DummyString22, !cir.ptr<!ty_22DummyString22>, ["s4", init] {alignment = 1 : i64}
+// CHECK-NEXT:     %0 = cir.alloca !ty_DummyString, !cir.ptr<!ty_DummyString>, ["s4", init] {alignment = 1 : i64}
 // CHECK-NEXT:     %1 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 5>>
 // CHECK-NEXT:     %2 = cir.cast(array_to_ptrdecay, %1 : !cir.ptr<!cir.array<!s8i x 5>>), !cir.ptr<!s8i>
-// CHECK-NEXT:     cir.call @_ZN11DummyStringC2EPKc(%0, %2) : (!cir.ptr<!ty_22DummyString22>, !cir.ptr<!s8i>) -> ()
+// CHECK-NEXT:     cir.call @_ZN11DummyStringC2EPKc(%0, %2) : (!cir.ptr<!ty_DummyString>, !cir.ptr<!s8i>) -> ()
 // CHECK-NEXT:     cir.return
 
 struct B {
@@ -31,10 +31,10 @@ struct B {
 B::B() {
 }
 
-// CHECK: cir.func @_ZN1BC2Ev(%arg0: !cir.ptr<!ty_22B22>
-// CHECK:   %0 = cir.alloca !cir.ptr<!ty_22B22>, !cir.ptr<!cir.ptr<!ty_22B22>>, ["this", init] {alignment = 8 : i64}
-// CHECK:   cir.store %arg0, %0 : !cir.ptr<!ty_22B22>, !cir.ptr<!cir.ptr<!ty_22B22>>
-// CHECK:   %1 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22B22>>, !cir.ptr<!ty_22B22>
+// CHECK: cir.func @_ZN1BC2Ev(%arg0: !cir.ptr<!ty_B>
+// CHECK:   %0 = cir.alloca !cir.ptr<!ty_B>, !cir.ptr<!cir.ptr<!ty_B>>, ["this", init] {alignment = 8 : i64}
+// CHECK:   cir.store %arg0, %0 : !cir.ptr<!ty_B>, !cir.ptr<!cir.ptr<!ty_B>>
+// CHECK:   %1 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_B>>, !cir.ptr<!ty_B>
 // CHECK:   cir.return
 // CHECK: }
-// CHECK: cir.func @_ZN1BC1Ev(!cir.ptr<!ty_22B22>) alias(@_ZN1BC2Ev)
\ No newline at end of file
+// CHECK: cir.func @_ZN1BC1Ev(!cir.ptr<!ty_B>) alias(@_ZN1BC2Ev)
\ No newline at end of file
diff --git a/clang/test/CIR/CodeGen/ctor-member-lvalue-to-rvalue.cpp b/clang/test/CIR/CodeGen/ctor-member-lvalue-to-rvalue.cpp
index 70fff5a81dfe..d8e42f46429f 100644
--- a/clang/test/CIR/CodeGen/ctor-member-lvalue-to-rvalue.cpp
+++ b/clang/test/CIR/CodeGen/ctor-member-lvalue-to-rvalue.cpp
@@ -6,8 +6,8 @@ struct String {
   long size;
   String(const String &s) : size{s.size} {}
 // CHECK: cir.func linkonce_odr @_ZN6StringC2ERKS_
-// CHECK:     %0 = cir.alloca !cir.ptr<!ty_22String22>, !cir.ptr<!cir.ptr<!ty_22String22>>, ["this", init] {alignment = 8 : i64}
-// CHECK:     %1 = cir.alloca !cir.ptr<!ty_22String22>, !cir.ptr<!cir.ptr<!ty_22String22>>, ["s", init] {alignment = 8 : i64}
+// CHECK:     %0 = cir.alloca !cir.ptr<!ty_String>, !cir.ptr<!cir.ptr<!ty_String>>, ["this", init] {alignment = 8 : i64}
+// CHECK:     %1 = cir.alloca !cir.ptr<!ty_String>, !cir.ptr<!cir.ptr<!ty_String>>, ["s", init] {alignment = 8 : i64}
 // CHECK:     cir.store %arg0, %0
 // CHECK:     cir.store %arg1, %1
 // CHECK:     %2 = cir.load %0
@@ -27,9 +27,9 @@ void foo() {
   String s1{s};
 }
 // CHECK: cir.func @_Z3foov() {{.*}} {
-// CHECK:  %0 = cir.alloca !ty_22String22, !cir.ptr<!ty_22String22>, ["s", init] {alignment = 8 : i64}
-// CHECK:  %1 = cir.alloca !ty_22String22, !cir.ptr<!ty_22String22>, ["s1", init] {alignment = 8 : i64}
-// CHECK:  cir.call @_ZN6StringC2Ev(%0) : (!cir.ptr<!ty_22String22>) -> ()
-// CHECK:  cir.call @_ZN6StringC2ERKS_(%1, %0) : (!cir.ptr<!ty_22String22>, !cir.ptr<!ty_22String22>) -> ()
+// CHECK:  %0 = cir.alloca !ty_String, !cir.ptr<!ty_String>, ["s", init] {alignment = 8 : i64}
+// CHECK:  %1 = cir.alloca !ty_String, !cir.ptr<!ty_String>, ["s1", init] {alignment = 8 : i64}
+// CHECK:  cir.call @_ZN6StringC2Ev(%0) : (!cir.ptr<!ty_String>) -> ()
+// CHECK:  cir.call @_ZN6StringC2ERKS_(%1, %0) : (!cir.ptr<!ty_String>, !cir.ptr<!ty_String>) -> ()
 // CHECK:  cir.return
 // }
diff --git a/clang/test/CIR/CodeGen/ctor.cpp b/clang/test/CIR/CodeGen/ctor.cpp
index a13487117b3f..9f8217532ac5 100644
--- a/clang/test/CIR/CodeGen/ctor.cpp
+++ b/clang/test/CIR/CodeGen/ctor.cpp
@@ -11,22 +11,22 @@ void baz() {
   Struk s;
 }
 
-// CHECK: !ty_22Struk22 = !cir.struct<struct "Struk" {!cir.int<s, 32>}>
+// CHECK: !ty_Struk = !cir.struct<struct "Struk" {!cir.int<s, 32>}>
 
-// CHECK:   cir.func linkonce_odr @_ZN5StrukC2Ev(%arg0: !cir.ptr<!ty_22Struk22>
-// CHECK-NEXT:     %0 = cir.alloca !cir.ptr<!ty_22Struk22>, !cir.ptr<!cir.ptr<!ty_22Struk22>>, ["this", init] {alignment = 8 : i64}
-// CHECK-NEXT:     cir.store %arg0, %0 : !cir.ptr<!ty_22Struk22>, !cir.ptr<!cir.ptr<!ty_22Struk22>>
-// CHECK-NEXT:     %1 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22Struk22>>, !cir.ptr<!ty_22Struk22>
+// CHECK:   cir.func linkonce_odr @_ZN5StrukC2Ev(%arg0: !cir.ptr<!ty_Struk>
+// CHECK-NEXT:     %0 = cir.alloca !cir.ptr<!ty_Struk>, !cir.ptr<!cir.ptr<!ty_Struk>>, ["this", init] {alignment = 8 : i64}
+// CHECK-NEXT:     cir.store %arg0, %0 : !cir.ptr<!ty_Struk>, !cir.ptr<!cir.ptr<!ty_Struk>>
+// CHECK-NEXT:     %1 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_Struk>>, !cir.ptr<!ty_Struk>
 // CHECK-NEXT:     cir.return
 
-// CHECK:   cir.func linkonce_odr @_ZN5StrukC1Ev(%arg0: !cir.ptr<!ty_22Struk22>
-// CHECK-NEXT:     %0 = cir.alloca !cir.ptr<!ty_22Struk22>, !cir.ptr<!cir.ptr<!ty_22Struk22>>, ["this", init] {alignment = 8 : i64}
-// CHECK-NEXT:     cir.store %arg0, %0 : !cir.ptr<!ty_22Struk22>, !cir.ptr<!cir.ptr<!ty_22Struk22>>
-// CHECK-NEXT:     %1 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22Struk22>>, !cir.ptr<!ty_22Struk22>
-// CHECK-NEXT:     cir.call @_ZN5StrukC2Ev(%1) : (!cir.ptr<!ty_22Struk22>) -> ()
+// CHECK:   cir.func linkonce_odr @_ZN5StrukC1Ev(%arg0: !cir.ptr<!ty_Struk>
+// CHECK-NEXT:     %0 = cir.alloca !cir.ptr<!ty_Struk>, !cir.ptr<!cir.ptr<!ty_Struk>>, ["this", init] {alignment = 8 : i64}
+// CHECK-NEXT:     cir.store %arg0, %0 : !cir.ptr<!ty_Struk>, !cir.ptr<!cir.ptr<!ty_Struk>>
+// CHECK-NEXT:     %1 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_Struk>>, !cir.ptr<!ty_Struk>
+// CHECK-NEXT:     cir.call @_ZN5StrukC2Ev(%1) : (!cir.ptr<!ty_Struk>) -> ()
 // CHECK-NEXT:     cir.return
 
 // CHECK:   cir.func @_Z3bazv()
-// CHECK-NEXT:     %0 = cir.alloca !ty_22Struk22, !cir.ptr<!ty_22Struk22>, ["s", init] {alignment = 4 : i64}
-// CHECK-NEXT:     cir.call @_ZN5StrukC1Ev(%0) : (!cir.ptr<!ty_22Struk22>) -> ()
+// CHECK-NEXT:     %0 = cir.alloca !ty_Struk, !cir.ptr<!ty_Struk>, ["s", init] {alignment = 4 : i64}
+// CHECK-NEXT:     cir.call @_ZN5StrukC1Ev(%0) : (!cir.ptr<!ty_Struk>) -> ()
 // CHECK-NEXT:     cir.return
diff --git a/clang/test/CIR/CodeGen/delegating-ctor.cpp b/clang/test/CIR/CodeGen/delegating-ctor.cpp
index b230ea6f1d5c..850c0aac9d6d 100644
--- a/clang/test/CIR/CodeGen/delegating-ctor.cpp
+++ b/clang/test/CIR/CodeGen/delegating-ctor.cpp
@@ -10,12 +10,12 @@ struct Delegating {
 // arguments.
 Delegating::Delegating() : Delegating(0) {}
 
-// CHECK-LABEL: cir.func @_ZN10DelegatingC2Ev(%arg0: !cir.ptr<!ty_22Delegating22> {{.*}}) {{.*}} {
-// CHECK-NEXT:    %0 = cir.alloca !cir.ptr<!ty_22Delegating22>, !cir.ptr<!cir.ptr<!ty_22Delegating22>>, ["this", init] {alignment = 8 : i64}
-// CHECK-NEXT:    cir.store %arg0, %0 : !cir.ptr<!ty_22Delegating22>, !cir.ptr<!cir.ptr<!ty_22Delegating22>>
-// CHECK-NEXT:    %1 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22Delegating22>>, !cir.ptr<!ty_22Delegating22>
+// CHECK-LABEL: cir.func @_ZN10DelegatingC2Ev(%arg0: !cir.ptr<!ty_Delegating> {{.*}}) {{.*}} {
+// CHECK-NEXT:    %0 = cir.alloca !cir.ptr<!ty_Delegating>, !cir.ptr<!cir.ptr<!ty_Delegating>>, ["this", init] {alignment = 8 : i64}
+// CHECK-NEXT:    cir.store %arg0, %0 : !cir.ptr<!ty_Delegating>, !cir.ptr<!cir.ptr<!ty_Delegating>>
+// CHECK-NEXT:    %1 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_Delegating>>, !cir.ptr<!ty_Delegating>
 // CHECK-NEXT:    %2 = cir.const #cir.int<0> : !s32i
-// CHECK-NEXT:    cir.call @_ZN10DelegatingC2Ei(%1, %2) : (!cir.ptr<!ty_22Delegating22>, !s32i) -> ()
+// CHECK-NEXT:    cir.call @_ZN10DelegatingC2Ei(%1, %2) : (!cir.ptr<!ty_Delegating>, !s32i) -> ()
 // CHECK-NEXT:    cir.return
 // CHECK-NEXT:  }
 
@@ -30,15 +30,15 @@ struct DelegatingWithZeroing {
 // call to it in a lowering pass.
 DelegatingWithZeroing::DelegatingWithZeroing(int) : DelegatingWithZeroing() {}
 
-// CHECK-LABEL: cir.func @_ZN21DelegatingWithZeroingC2Ei(%arg0: !cir.ptr<!ty_22DelegatingWithZeroing22> {{.*}}, %arg1: !s32i {{.*}}) {{.*}} {
-// CHECK-NEXT:    %0 = cir.alloca !cir.ptr<!ty_22DelegatingWithZeroing22>, !cir.ptr<!cir.ptr<!ty_22DelegatingWithZeroing22>>, ["this", init] {alignment = 8 : i64}
+// CHECK-LABEL: cir.func @_ZN21DelegatingWithZeroingC2Ei(%arg0: !cir.ptr<!ty_DelegatingWithZeroing> {{.*}}, %arg1: !s32i {{.*}}) {{.*}} {
+// CHECK-NEXT:    %0 = cir.alloca !cir.ptr<!ty_DelegatingWithZeroing>, !cir.ptr<!cir.ptr<!ty_DelegatingWithZeroing>>, ["this", init] {alignment = 8 : i64}
 // CHECK-NEXT:    %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["", init] {alignment = 4 : i64}
-// CHECK-NEXT:    cir.store %arg0, %0 : !cir.ptr<!ty_22DelegatingWithZeroing22>, !cir.ptr<!cir.ptr<!ty_22DelegatingWithZeroing22>>
+// CHECK-NEXT:    cir.store %arg0, %0 : !cir.ptr<!ty_DelegatingWithZeroing>, !cir.ptr<!cir.ptr<!ty_DelegatingWithZeroing>>
 // CHECK-NEXT:    cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
-// CHECK-NEXT:    %2 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22DelegatingWithZeroing22>>, !cir.ptr<!ty_22DelegatingWithZeroing22>
-// CHECK-NEXT:    %3 = cir.const #cir.zero : !ty_22DelegatingWithZeroing22
-// CHECK-NEXT:    cir.store %3, %2 : !ty_22DelegatingWithZeroing22, !cir.ptr<!ty_22DelegatingWithZeroing22>
-// CHECK-NEXT:    cir.call @_ZN21DelegatingWithZeroingC2Ev(%2) : (!cir.ptr<!ty_22DelegatingWithZeroing22>) -> () extra(#fn_attr1)
+// CHECK-NEXT:    %2 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_DelegatingWithZeroing>>, !cir.ptr<!ty_DelegatingWithZeroing>
+// CHECK-NEXT:    %3 = cir.const #cir.zero : !ty_DelegatingWithZeroing
+// CHECK-NEXT:    cir.store %3, %2 : !ty_DelegatingWithZeroing, !cir.ptr<!ty_DelegatingWithZeroing>
+// CHECK-NEXT:    cir.call @_ZN21DelegatingWithZeroingC2Ev(%2) : (!cir.ptr<!ty_DelegatingWithZeroing>) -> () extra(#fn_attr1)
 // CHECK-NEXT:    cir.return
 // CHECK-NEXT:  }
 
diff --git a/clang/test/CIR/CodeGen/derived-to-base.cpp b/clang/test/CIR/CodeGen/derived-to-base.cpp
index 160a83c31fc4..ad8bf4b2a736 100644
--- a/clang/test/CIR/CodeGen/derived-to-base.cpp
+++ b/clang/test/CIR/CodeGen/derived-to-base.cpp
@@ -75,32 +75,32 @@ void C3::Layer::Initialize() {
   }
 }
 
-// CHECK-DAG: !ty_22C23A3ALayer22 = !cir.struct<class "C2::Layer"
-// CHECK-DAG: !ty_22C33A3ALayer22 = !cir.struct<struct "C3::Layer"
-// CHECK-DAG: !ty_22A22 = !cir.struct<class "A"
-// CHECK-DAG: !ty_22A2Ebase22 = !cir.struct<class "A.base"
-// CHECK-DAG: !ty_22B22 = !cir.struct<class "B" {!cir.struct<class "A.base"
+// CHECK-DAG: !ty_C23A3ALayer = !cir.struct<class "C2::Layer"
+// CHECK-DAG: !ty_C33A3ALayer = !cir.struct<struct "C3::Layer"
+// CHECK-DAG: !ty_A = !cir.struct<class "A"
+// CHECK-DAG: !ty_A2Ebase = !cir.struct<class "A.base"
+// CHECK-DAG: !ty_B = !cir.struct<class "B" {!cir.struct<class "A.base"
 
 // CHECK: cir.func @_ZN2C35Layer10InitializeEv
 
 // CHECK:  cir.scope {
-// CHECK:    %2 = cir.base_class_addr(%1 : !cir.ptr<!ty_22C33A3ALayer22>) -> !cir.ptr<!ty_22C23A3ALayer22>
-// CHECK:    %3 = cir.get_member %2[1] {name = "m_C1"} : !cir.ptr<!ty_22C23A3ALayer22> -> !cir.ptr<!cir.ptr<!ty_22C222>>
-// CHECK:    %4 = cir.load %3 : !cir.ptr<!cir.ptr<!ty_22C222>>, !cir.ptr<!ty_22C222>
-// CHECK:    %5 = cir.const #cir.ptr<null> : !cir.ptr<!ty_22C222>
-// CHECK:    %6 = cir.cmp(eq, %4, %5) : !cir.ptr<!ty_22C222>, !cir.bool
+// CHECK:    %2 = cir.base_class_addr(%1 : !cir.ptr<!ty_C33A3ALayer>) -> !cir.ptr<!ty_C23A3ALayer>
+// CHECK:    %3 = cir.get_member %2[1] {name = "m_C1"} : !cir.ptr<!ty_C23A3ALayer> -> !cir.ptr<!cir.ptr<!ty_C2_>>
+// CHECK:    %4 = cir.load %3 : !cir.ptr<!cir.ptr<!ty_C2_>>, !cir.ptr<!ty_C2_>
+// CHECK:    %5 = cir.const #cir.ptr<null> : !cir.ptr<!ty_C2_>
+// CHECK:    %6 = cir.cmp(eq, %4, %5) : !cir.ptr<!ty_C2_>, !cir.bool
 
 enumy C3::Initialize() {
   return C2::Initialize();
 }
 
-// CHECK: cir.func @_ZN2C310InitializeEv(%arg0: !cir.ptr<!ty_22C322>
-// CHECK:     %0 = cir.alloca !cir.ptr<!ty_22C322>, !cir.ptr<!cir.ptr<!ty_22C322>>, ["this", init] {alignment = 8 : i64}
+// CHECK: cir.func @_ZN2C310InitializeEv(%arg0: !cir.ptr<!ty_C3_>
+// CHECK:     %0 = cir.alloca !cir.ptr<!ty_C3_>, !cir.ptr<!cir.ptr<!ty_C3_>>, ["this", init] {alignment = 8 : i64}
 
-// CHECK:     cir.store %arg0, %0 : !cir.ptr<!ty_22C322>, !cir.ptr<!cir.ptr<!ty_22C322>>
-// CHECK:     %2 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22C322>>, !cir.ptr<!ty_22C322>
-// CHECK:     %3 = cir.base_class_addr(%2 : !cir.ptr<!ty_22C322>) -> !cir.ptr<!ty_22C222>
-// CHECK:     %4 = cir.call @_ZN2C210InitializeEv(%3) : (!cir.ptr<!ty_22C222>) -> !s32i
+// CHECK:     cir.store %arg0, %0 : !cir.ptr<!ty_C3_>, !cir.ptr<!cir.ptr<!ty_C3_>>
+// CHECK:     %2 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_C3_>>, !cir.ptr<!ty_C3_>
+// CHECK:     %3 = cir.base_class_addr(%2 : !cir.ptr<!ty_C3_>) -> !cir.ptr<!ty_C2_>
+// CHECK:     %4 = cir.call @_ZN2C210InitializeEv(%3) : (!cir.ptr<!ty_C2_>) -> !s32i
 
 void vcall(C1 &c1) {
   buffy b;
@@ -108,21 +108,21 @@ void vcall(C1 &c1) {
   c1.SetStuff(e, b);
 }
 
-// CHECK: cir.func @_Z5vcallR2C1(%arg0: !cir.ptr<!ty_22C122>
-// CHECK:   %0 = cir.alloca !cir.ptr<!ty_22C122>, !cir.ptr<!cir.ptr<!ty_22C122>>, ["c1", init] {alignment = 8 : i64}
-// CHECK:   %1 = cir.alloca !ty_22buffy22, !cir.ptr<!ty_22buffy22>, ["b"] {alignment = 8 : i64}
+// CHECK: cir.func @_Z5vcallR2C1(%arg0: !cir.ptr<!ty_C1_>
+// CHECK:   %0 = cir.alloca !cir.ptr<!ty_C1_>, !cir.ptr<!cir.ptr<!ty_C1_>>, ["c1", init] {alignment = 8 : i64}
+// CHECK:   %1 = cir.alloca !ty_buffy, !cir.ptr<!ty_buffy>, ["b"] {alignment = 8 : i64}
 // CHECK:   %2 = cir.alloca !s32i, !cir.ptr<!s32i>, ["e"] {alignment = 4 : i64}
-// CHECK:   %3 = cir.alloca !ty_22buffy22, !cir.ptr<!ty_22buffy22>, ["agg.tmp0"] {alignment = 8 : i64}
-// CHECK:   cir.store %arg0, %0 : !cir.ptr<!ty_22C122>, !cir.ptr<!cir.ptr<!ty_22C122>>
-// CHECK:   %4 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22C122>>, !cir.ptr<!ty_22C122>
+// CHECK:   %3 = cir.alloca !ty_buffy, !cir.ptr<!ty_buffy>, ["agg.tmp0"] {alignment = 8 : i64}
+// CHECK:   cir.store %arg0, %0 : !cir.ptr<!ty_C1_>, !cir.ptr<!cir.ptr<!ty_C1_>>
+// CHECK:   %4 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_C1_>>, !cir.ptr<!ty_C1_>
 // CHECK:   %5 = cir.load %2 : !cir.ptr<!s32i>, !s32i
-// CHECK:   cir.call @_ZN5buffyC2ERKS_(%3, %1) : (!cir.ptr<!ty_22buffy22>, !cir.ptr<!ty_22buffy22>) -> ()
-// CHECK:   %6 = cir.load %3 : !cir.ptr<!ty_22buffy22>, !ty_22buffy22
-// CHECK:   %7 = cir.cast(bitcast, %4 : !cir.ptr<!ty_22C122>), !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22C122>, !s32i, !ty_22buffy22)>>>>
-// CHECK:   %8 = cir.load %7 : !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22C122>, !s32i, !ty_22buffy22)>>>>, !cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22C122>, !s32i, !ty_22buffy22)>>>
-// CHECK:   %9 = cir.vtable.address_point( %8 : !cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22C122>, !s32i, !ty_22buffy22)>>>, vtable_index = 0, address_point_index = 2) : !cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22C122>, !s32i, !ty_22buffy22)>>>
-// CHECK:   %10 = cir.load align(8) %9 : !cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22C122>, !s32i, !ty_22buffy22)>>>, !cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22C122>, !s32i, !ty_22buffy22)>>
-// CHECK:   %11 = cir.call %10(%4, %5, %6) : (!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22C122>, !s32i, !ty_22buffy22)>>, !cir.ptr<!ty_22C122>, !s32i, !ty_22buffy22) -> !s32i
+// CHECK:   cir.call @_ZN5buffyC2ERKS_(%3, %1) : (!cir.ptr<!ty_buffy>, !cir.ptr<!ty_buffy>) -> ()
+// CHECK:   %6 = cir.load %3 : !cir.ptr<!ty_buffy>, !ty_buffy
+// CHECK:   %7 = cir.cast(bitcast, %4 : !cir.ptr<!ty_C1_>), !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_C1_>, !s32i, !ty_buffy)>>>>
+// CHECK:   %8 = cir.load %7 : !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_C1_>, !s32i, !ty_buffy)>>>>, !cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_C1_>, !s32i, !ty_buffy)>>>
+// CHECK:   %9 = cir.vtable.address_point( %8 : !cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_C1_>, !s32i, !ty_buffy)>>>, vtable_index = 0, address_point_index = 2) : !cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_C1_>, !s32i, !ty_buffy)>>>
+// CHECK:   %10 = cir.load align(8) %9 : !cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_C1_>, !s32i, !ty_buffy)>>>, !cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_C1_>, !s32i, !ty_buffy)>>
+// CHECK:   %11 = cir.call %10(%4, %5, %6) : (!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_C1_>, !s32i, !ty_buffy)>>, !cir.ptr<!ty_C1_>, !s32i, !ty_buffy) -> !s32i
 // CHECK:   cir.return
 // CHECK: }
 
@@ -138,19 +138,19 @@ class B : public A {
   void foo ()  { static_cast<A>(*this).foo();}
 };
 
-// CHECK: cir.func linkonce_odr @_ZN1B3fooEv(%arg0: !cir.ptr<!ty_22B22>
-// CHECK:   %0 = cir.alloca !cir.ptr<!ty_22B22>, !cir.ptr<!cir.ptr<!ty_22B22>>, ["this", init] {alignment = 8 : i64}
-// CHECK:   cir.store %arg0, %0 : !cir.ptr<!ty_22B22>, !cir.ptr<!cir.ptr<!ty_22B22>>
-// CHECK:   %1 = cir.load deref %0 : !cir.ptr<!cir.ptr<!ty_22B22>>, !cir.ptr<!ty_22B22>
+// CHECK: cir.func linkonce_odr @_ZN1B3fooEv(%arg0: !cir.ptr<!ty_B>
+// CHECK:   %0 = cir.alloca !cir.ptr<!ty_B>, !cir.ptr<!cir.ptr<!ty_B>>, ["this", init] {alignment = 8 : i64}
+// CHECK:   cir.store %arg0, %0 : !cir.ptr<!ty_B>, !cir.ptr<!cir.ptr<!ty_B>>
+// CHECK:   %1 = cir.load deref %0 : !cir.ptr<!cir.ptr<!ty_B>>, !cir.ptr<!ty_B>
 // CHECK:   cir.scope {
-// CHECK:     %2 = cir.alloca !ty_22A22, !cir.ptr<!ty_22A22>, ["ref.tmp0"] {alignment = 8 : i64}
-// CHECK:     %3 = cir.base_class_addr(%1 : !cir.ptr<!ty_22B22>) -> !cir.ptr<!ty_22A22>
+// CHECK:     %2 = cir.alloca !ty_A, !cir.ptr<!ty_A>, ["ref.tmp0"] {alignment = 8 : i64}
+// CHECK:     %3 = cir.base_class_addr(%1 : !cir.ptr<!ty_B>) -> !cir.ptr<!ty_A>
 
 // Call @A::A(A const&)
-// CHECK:     cir.call @_ZN1AC2ERKS_(%2, %3) : (!cir.ptr<!ty_22A22>, !cir.ptr<!ty_22A22>) -> ()
+// CHECK:     cir.call @_ZN1AC2ERKS_(%2, %3) : (!cir.ptr<!ty_A>, !cir.ptr<!ty_A>) -> ()
 
 // Call @A::foo()
-// CHECK:     cir.call @_ZN1A3fooEv(%2) : (!cir.ptr<!ty_22A22>) -> ()
+// CHECK:     cir.call @_ZN1A3fooEv(%2) : (!cir.ptr<!ty_A>) -> ()
 // CHECK:   }
 // CHECK:   cir.return
 // CHECK: }
diff --git a/clang/test/CIR/CodeGen/dtors-scopes.cpp b/clang/test/CIR/CodeGen/dtors-scopes.cpp
index 4c10b4d64426..6d363f0254bf 100644
--- a/clang/test/CIR/CodeGen/dtors-scopes.cpp
+++ b/clang/test/CIR/CodeGen/dtors-scopes.cpp
@@ -17,9 +17,9 @@ void dtor1() {
 
 // CHECK: cir.func @_Z5dtor1v()
 // CHECK:   cir.scope {
-// CHECK:     %4 = cir.alloca !ty_22C22, !cir.ptr<!ty_22C22>, ["c", init] {alignment = 1 : i64}
-// CHECK:     cir.call @_ZN1CC2Ev(%4) : (!cir.ptr<!ty_22C22>) -> ()
-// CHECK:     cir.call @_ZN1CD2Ev(%4) : (!cir.ptr<!ty_22C22>) -> ()
+// CHECK:     %4 = cir.alloca !ty_C, !cir.ptr<!ty_C>, ["c", init] {alignment = 1 : i64}
+// CHECK:     cir.call @_ZN1CC2Ev(%4) : (!cir.ptr<!ty_C>) -> ()
+// CHECK:     cir.call @_ZN1CD2Ev(%4) : (!cir.ptr<!ty_C>) -> ()
 // CHECK:   }
 
 // DTOR_BODY: cir.func linkonce_odr @_ZN1CD2Ev{{.*}}{
@@ -29,7 +29,7 @@ void dtor1() {
 // DTOR_BODY:   %5 = cir.call @printf(%4)
 // DTOR_BODY:   cir.return
 
-// DTOR_BODY: cir.func linkonce_odr @_ZN1CD1Ev(%arg0: !cir.ptr<!ty_22C22>
+// DTOR_BODY: cir.func linkonce_odr @_ZN1CD1Ev(%arg0: !cir.ptr<!ty_C>
 
 // DTOR_BODY:   cir.call @_ZN1CD2Ev
 // DTOR_BODY:   cir.return
diff --git a/clang/test/CIR/CodeGen/dtors.cpp b/clang/test/CIR/CodeGen/dtors.cpp
index b8cb4ea65a70..fe07c0ff1245 100644
--- a/clang/test/CIR/CodeGen/dtors.cpp
+++ b/clang/test/CIR/CodeGen/dtors.cpp
@@ -43,11 +43,11 @@ class B : public A
 // CHECK: ![[ClassB:ty_.*]] = !cir.struct<class "B" {!cir.struct<class "A" {!cir.ptr<!cir.ptr<!cir.func<!cir.int<u, 32> ()>>>} #cir.record.decl.ast>}>
 
 // CHECK: cir.func @_Z4bluev()
-// CHECK:   %0 = cir.alloca !ty_22PSEvent22, !cir.ptr<!ty_22PSEvent22>, ["p", init] {alignment = 8 : i64}
+// CHECK:   %0 = cir.alloca !ty_PSEvent, !cir.ptr<!ty_PSEvent>, ["p", init] {alignment = 8 : i64}
 // CHECK:   %1 = cir.const #cir.int<1> : !s32i
 // CHECK:   %2 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 5>>
 // CHECK:   %3 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr<!cir.array<!s8i x 5>>), !cir.ptr<!s8i>
-// CHECK:   cir.call @_ZN7PSEventC1E6EFModePKc(%0, %1, %3) : (!cir.ptr<!ty_22PSEvent22>, !s32i, !cir.ptr<!s8i>) -> ()
+// CHECK:   cir.call @_ZN7PSEventC1E6EFModePKc(%0, %1, %3) : (!cir.ptr<!ty_PSEvent>, !s32i, !cir.ptr<!s8i>) -> ()
 // CHECK:   cir.return
 // CHECK: }
 
@@ -58,8 +58,8 @@ class B : public A
 // void foo()
 // CHECK: cir.func @_Z3foov()
 // CHECK:   cir.scope {
-// CHECK:     cir.call @_ZN1BC2Ev(%0) : (!cir.ptr<!ty_22B22>) -> ()
-// CHECK:     cir.call @_ZN1BD2Ev(%0) : (!cir.ptr<!ty_22B22>) -> ()
+// CHECK:     cir.call @_ZN1BC2Ev(%0) : (!cir.ptr<!ty_B>) -> ()
+// CHECK:     cir.call @_ZN1BD2Ev(%0) : (!cir.ptr<!ty_B>) -> ()
 
 // operator delete(void*) declaration
 // CHECK:   cir.func private @_ZdlPvm(!cir.ptr<!void>, !u64i)
diff --git a/clang/test/CIR/CodeGen/dynamic-cast-exact.cpp b/clang/test/CIR/CodeGen/dynamic-cast-exact.cpp
index 78542d962575..6ff93c998927 100644
--- a/clang/test/CIR/CodeGen/dynamic-cast-exact.cpp
+++ b/clang/test/CIR/CodeGen/dynamic-cast-exact.cpp
@@ -15,18 +15,18 @@ struct Derived final : Base1 {};
 
 Derived *ptr_cast(Base1 *ptr) {
   return dynamic_cast<Derived *>(ptr);
-  //      CHECK: %[[#SRC:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_22Base122>>, !cir.ptr<!ty_22Base122>
+  //      CHECK: %[[#SRC:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_Base1_>>, !cir.ptr<!ty_Base1_>
   // CHECK-NEXT: %[[#EXPECTED_VPTR:]] = cir.vtable.address_point(@_ZTV7Derived, vtable_index = 0, address_point_index = 2) : !cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>
-  // CHECK-NEXT: %[[#SRC_VPTR_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_22Base122>), !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>>
+  // CHECK-NEXT: %[[#SRC_VPTR_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_Base1_>), !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>>
   // CHECK-NEXT: %[[#SRC_VPTR:]] = cir.load %[[#SRC_VPTR_PTR]] : !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>>, !cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>
   // CHECK-NEXT: %[[#SUCCESS:]] = cir.cmp(eq, %[[#SRC_VPTR]], %[[#EXPECTED_VPTR]]) : !cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>, !cir.bool
   // CHECK-NEXT: %{{.+}} = cir.ternary(%[[#SUCCESS]], true {
-  // CHECK-NEXT:   %[[#RES:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_22Base122>), !cir.ptr<!ty_22Derived22>
-  // CHECK-NEXT:   cir.yield %[[#RES]] : !cir.ptr<!ty_22Derived22>
+  // CHECK-NEXT:   %[[#RES:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_Base1_>), !cir.ptr<!ty_Derived>
+  // CHECK-NEXT:   cir.yield %[[#RES]] : !cir.ptr<!ty_Derived>
   // CHECK-NEXT: }, false {
-  // CHECK-NEXT:   %[[#NULL:]] = cir.const #cir.ptr<null> : !cir.ptr<!ty_22Derived22>
-  // CHECK-NEXT:   cir.yield %[[#NULL]] : !cir.ptr<!ty_22Derived22>
-  // CHECK-NEXT: }) : (!cir.bool) -> !cir.ptr<!ty_22Derived22>
+  // CHECK-NEXT:   %[[#NULL:]] = cir.const #cir.ptr<null> : !cir.ptr<!ty_Derived>
+  // CHECK-NEXT:   cir.yield %[[#NULL]] : !cir.ptr<!ty_Derived>
+  // CHECK-NEXT: }) : (!cir.bool) -> !cir.ptr<!ty_Derived>
 }
 
 //      LLVM: define dso_local ptr @_Z8ptr_castP5Base1(ptr readonly %[[#SRC:]])
@@ -38,9 +38,9 @@ Derived *ptr_cast(Base1 *ptr) {
 
 Derived &ref_cast(Base1 &ref) {
   return dynamic_cast<Derived &>(ref);
-  //      CHECK: %[[#SRC:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_22Base122>>, !cir.ptr<!ty_22Base122>
+  //      CHECK: %[[#SRC:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_Base1_>>, !cir.ptr<!ty_Base1_>
   // CHECK-NEXT: %[[#EXPECTED_VPTR:]] = cir.vtable.address_point(@_ZTV7Derived, vtable_index = 0, address_point_index = 2) : !cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>
-  // CHECK-NEXT: %[[#SRC_VPTR_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_22Base122>), !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>>
+  // CHECK-NEXT: %[[#SRC_VPTR_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_Base1_>), !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>>
   // CHECK-NEXT: %[[#SRC_VPTR:]] = cir.load %[[#SRC_VPTR_PTR]] : !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>>, !cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>
   // CHECK-NEXT: %[[#SUCCESS:]] = cir.cmp(eq, %[[#SRC_VPTR]], %[[#EXPECTED_VPTR]]) : !cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>, !cir.bool
   // CHECK-NEXT: %[[#FAILED:]] = cir.unary(not, %[[#SUCCESS]]) : !cir.bool, !cir.bool
@@ -48,7 +48,7 @@ Derived &ref_cast(Base1 &ref) {
   // CHECK-NEXT:   cir.call @__cxa_bad_cast() : () -> ()
   // CHECK-NEXT:   cir.unreachable
   // CHECK-NEXT: }
-  // CHECK-NEXT: %{{.+}} = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_22Base122>), !cir.ptr<!ty_22Derived22>
+  // CHECK-NEXT: %{{.+}} = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_Base1_>), !cir.ptr<!ty_Derived>
 }
 
 //      LLVM: define dso_local noundef ptr @_Z8ref_castR5Base1(ptr readonly returned %[[#SRC:]])
@@ -64,9 +64,9 @@ Derived &ref_cast(Base1 &ref) {
 
 Derived *ptr_cast_always_fail(Base2 *ptr) {
   return dynamic_cast<Derived *>(ptr);
-  //      CHECK: %{{.+}} = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_22Base222>>, !cir.ptr<!ty_22Base222>
-  // CHECK-NEXT: %[[#RESULT:]] = cir.const #cir.ptr<null> : !cir.ptr<!ty_22Derived22>
-  // CHECK-NEXT: cir.store %[[#RESULT]], %{{.+}} : !cir.ptr<!ty_22Derived22>, !cir.ptr<!cir.ptr<!ty_22Derived22>>
+  //      CHECK: %{{.+}} = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_Base2_>>, !cir.ptr<!ty_Base2_>
+  // CHECK-NEXT: %[[#RESULT:]] = cir.const #cir.ptr<null> : !cir.ptr<!ty_Derived>
+  // CHECK-NEXT: cir.store %[[#RESULT]], %{{.+}} : !cir.ptr<!ty_Derived>, !cir.ptr<!cir.ptr<!ty_Derived>>
 }
 
 //      LLVM: define dso_local noalias noundef ptr @_Z20ptr_cast_always_failP5Base2(ptr nocapture readnone %{{.+}})
@@ -75,8 +75,8 @@ Derived *ptr_cast_always_fail(Base2 *ptr) {
 
 Derived &ref_cast_always_fail(Base2 &ref) {
   return dynamic_cast<Derived &>(ref);
-  //      CHECK: %{{.+}} = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_22Base222>>, !cir.ptr<!ty_22Base222>
-  // CHECK-NEXT: %{{.+}} = cir.const #cir.ptr<null> : !cir.ptr<!ty_22Derived22>
+  //      CHECK: %{{.+}} = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_Base2_>>, !cir.ptr<!ty_Base2_>
+  // CHECK-NEXT: %{{.+}} = cir.const #cir.ptr<null> : !cir.ptr<!ty_Derived>
   // CHECK-NEXT: cir.call @__cxa_bad_cast() : () -> ()
   // CHECK-NEXT: cir.unreachable
 }
diff --git a/clang/test/CIR/CodeGen/dynamic-cast-relative-layout.cpp b/clang/test/CIR/CodeGen/dynamic-cast-relative-layout.cpp
index 58da33f0e60e..27cff8b2d172 100644
--- a/clang/test/CIR/CodeGen/dynamic-cast-relative-layout.cpp
+++ b/clang/test/CIR/CodeGen/dynamic-cast-relative-layout.cpp
@@ -5,25 +5,25 @@ struct Base {
   virtual ~Base();
 };
 
-// BEFORE: !ty_22Base22 = !cir.struct<struct "Base"
+// BEFORE: !ty_Base = !cir.struct<struct "Base"
 
 void *ptr_cast_to_complete(Base *ptr) {
   return dynamic_cast<void *>(ptr);
 }
 
 // BEFORE: cir.func @_Z20ptr_cast_to_completeP4Base
-// BEFORE:   %{{.+}} = cir.dyn_cast(ptr, %{{.+}} : !cir.ptr<!ty_22Base22> relative_layout) -> !cir.ptr<!void>
+// BEFORE:   %{{.+}} = cir.dyn_cast(ptr, %{{.+}} : !cir.ptr<!ty_Base> relative_layout) -> !cir.ptr<!void>
 // BEFORE: }
 
 //      AFTER: cir.func @_Z20ptr_cast_to_completeP4Base
-//      AFTER:   %[[#SRC:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_22Base22>>, !cir.ptr<!ty_22Base22>
-// AFTER-NEXT:   %[[#SRC_IS_NOT_NULL:]] = cir.cast(ptr_to_bool, %[[#SRC]] : !cir.ptr<!ty_22Base22>), !cir.bool
+//      AFTER:   %[[#SRC:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_Base>>, !cir.ptr<!ty_Base>
+// AFTER-NEXT:   %[[#SRC_IS_NOT_NULL:]] = cir.cast(ptr_to_bool, %[[#SRC]] : !cir.ptr<!ty_Base>), !cir.bool
 // AFTER-NEXT:   %{{.+}} = cir.ternary(%[[#SRC_IS_NOT_NULL]], true {
-// AFTER-NEXT:     %[[#VPTR_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_22Base22>), !cir.ptr<!cir.ptr<!s32i>>
+// AFTER-NEXT:     %[[#VPTR_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_Base>), !cir.ptr<!cir.ptr<!s32i>>
 // AFTER-NEXT:     %[[#VPTR:]] = cir.load %[[#VPTR_PTR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // AFTER-NEXT:     %[[#OFFSET_TO_TOP_PTR:]] = cir.vtable.address_point( %[[#VPTR]] : !cir.ptr<!s32i>, vtable_index = 0, address_point_index = -2) : !cir.ptr<!s32i>
 // AFTER-NEXT:     %[[#OFFSET_TO_TOP:]] = cir.load align(4) %[[#OFFSET_TO_TOP_PTR]] : !cir.ptr<!s32i>, !s32i
-// AFTER-NEXT:     %[[#SRC_BYTES_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_22Base22>), !cir.ptr<!u8i>
+// AFTER-NEXT:     %[[#SRC_BYTES_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_Base>), !cir.ptr<!u8i>
 // AFTER-NEXT:     %[[#DST_BYTES_PTR:]] = cir.ptr_stride(%[[#SRC_BYTES_PTR]] : !cir.ptr<!u8i>, %[[#OFFSET_TO_TOP]] : !s32i), !cir.ptr<!u8i>
 // AFTER-NEXT:     %[[#DST:]] = cir.cast(bitcast, %[[#DST_BYTES_PTR]] : !cir.ptr<!u8i>), !cir.ptr<!void>
 // AFTER-NEXT:     cir.yield %[[#DST]] : !cir.ptr<!void>
diff --git a/clang/test/CIR/CodeGen/dynamic-cast.cpp b/clang/test/CIR/CodeGen/dynamic-cast.cpp
index 622702104707..2d1393b4a582 100644
--- a/clang/test/CIR/CodeGen/dynamic-cast.cpp
+++ b/clang/test/CIR/CodeGen/dynamic-cast.cpp
@@ -8,32 +8,32 @@ struct Base {
 struct Derived : Base {};
 
 // BEFORE: #dyn_cast_info__ZTI4Base__ZTI7Derived = #cir.dyn_cast_info<#cir.global_view<@_ZTI4Base> : !cir.ptr<!u8i>, #cir.global_view<@_ZTI7Derived> : !cir.ptr<!u8i>, @__dynamic_cast, @__cxa_bad_cast, #cir.int<0> : !s64i>
-// BEFORE: !ty_22Base22 = !cir.struct
-// BEFORE: !ty_22Derived22 = !cir.struct
+// BEFORE: !ty_Base = !cir.struct
+// BEFORE: !ty_Derived = !cir.struct
 
 Derived *ptr_cast(Base *b) {
   return dynamic_cast<Derived *>(b);
 }
 
 // BEFORE: cir.func @_Z8ptr_castP4Base
-// BEFORE:   %{{.+}} = cir.dyn_cast(ptr, %{{.+}} : !cir.ptr<!ty_22Base22>, #dyn_cast_info__ZTI4Base__ZTI7Derived) -> !cir.ptr<!ty_22Derived22>
+// BEFORE:   %{{.+}} = cir.dyn_cast(ptr, %{{.+}} : !cir.ptr<!ty_Base>, #dyn_cast_info__ZTI4Base__ZTI7Derived) -> !cir.ptr<!ty_Derived>
 // BEFORE: }
 
 //      AFTER: cir.func @_Z8ptr_castP4Base
-//      AFTER:   %[[#SRC:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_22Base22>>, !cir.ptr<!ty_22Base22>
-// AFTER-NEXT:   %[[#SRC_IS_NOT_NULL:]] = cir.cast(ptr_to_bool, %[[#SRC]] : !cir.ptr<!ty_22Base22>), !cir.bool
+//      AFTER:   %[[#SRC:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_Base>>, !cir.ptr<!ty_Base>
+// AFTER-NEXT:   %[[#SRC_IS_NOT_NULL:]] = cir.cast(ptr_to_bool, %[[#SRC]] : !cir.ptr<!ty_Base>), !cir.bool
 // AFTER-NEXT:   %{{.+}} = cir.ternary(%[[#SRC_IS_NOT_NULL]], true {
-// AFTER-NEXT:     %[[#SRC_VOID_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_22Base22>), !cir.ptr<!void>
+// AFTER-NEXT:     %[[#SRC_VOID_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_Base>), !cir.ptr<!void>
 // AFTER-NEXT:     %[[#BASE_RTTI:]] = cir.const #cir.global_view<@_ZTI4Base> : !cir.ptr<!u8i>
 // AFTER-NEXT:     %[[#DERIVED_RTTI:]] = cir.const #cir.global_view<@_ZTI7Derived> : !cir.ptr<!u8i>
 // AFTER-NEXT:     %[[#HINT:]] = cir.const #cir.int<0> : !s64i
 // AFTER-NEXT:     %[[#RT_CALL_RET:]] = cir.call @__dynamic_cast(%[[#SRC_VOID_PTR]], %[[#BASE_RTTI]], %[[#DERIVED_RTTI]], %[[#HINT]]) : (!cir.ptr<!void>, !cir.ptr<!u8i>, !cir.ptr<!u8i>, !s64i) -> !cir.ptr<!void>
-// AFTER-NEXT:     %[[#CASTED:]] = cir.cast(bitcast, %[[#RT_CALL_RET]] : !cir.ptr<!void>), !cir.ptr<!ty_22Derived22>
-// AFTER-NEXT:     cir.yield %[[#CASTED]] : !cir.ptr<!ty_22Derived22>
+// AFTER-NEXT:     %[[#CASTED:]] = cir.cast(bitcast, %[[#RT_CALL_RET]] : !cir.ptr<!void>), !cir.ptr<!ty_Derived>
+// AFTER-NEXT:     cir.yield %[[#CASTED]] : !cir.ptr<!ty_Derived>
 // AFTER-NEXT:   }, false {
-// AFTER-NEXT:     %[[#NULL_PTR:]] = cir.const #cir.ptr<null> : !cir.ptr<!ty_22Derived22>
-// AFTER-NEXT:     cir.yield %[[#NULL_PTR]] : !cir.ptr<!ty_22Derived22>
-// AFTER-NEXT:   }) : (!cir.bool) -> !cir.ptr<!ty_22Derived22>
+// AFTER-NEXT:     %[[#NULL_PTR:]] = cir.const #cir.ptr<null> : !cir.ptr<!ty_Derived>
+// AFTER-NEXT:     cir.yield %[[#NULL_PTR]] : !cir.ptr<!ty_Derived>
+// AFTER-NEXT:   }) : (!cir.bool) -> !cir.ptr<!ty_Derived>
 //      AFTER: }
 
 Derived &ref_cast(Base &b) {
@@ -41,11 +41,11 @@ Derived &ref_cast(Base &b) {
 }
 
 // BEFORE: cir.func @_Z8ref_castR4Base
-// BEFORE:   %{{.+}} = cir.dyn_cast(ref, %{{.+}} : !cir.ptr<!ty_22Base22>, #dyn_cast_info__ZTI4Base__ZTI7Derived) -> !cir.ptr<!ty_22Derived22>
+// BEFORE:   %{{.+}} = cir.dyn_cast(ref, %{{.+}} : !cir.ptr<!ty_Base>, #dyn_cast_info__ZTI4Base__ZTI7Derived) -> !cir.ptr<!ty_Derived>
 // BEFORE: }
 
 //      AFTER: cir.func @_Z8ref_castR4Base
-//      AFTER:   %[[#SRC_VOID_PTR:]] = cir.cast(bitcast, %{{.+}} : !cir.ptr<!ty_22Base22>), !cir.ptr<!void>
+//      AFTER:   %[[#SRC_VOID_PTR:]] = cir.cast(bitcast, %{{.+}} : !cir.ptr<!ty_Base>), !cir.ptr<!void>
 // AFTER-NEXT:   %[[#SRC_RTTI:]] = cir.const #cir.global_view<@_ZTI4Base> : !cir.ptr<!u8i>
 // AFTER-NEXT:   %[[#DEST_RTTI:]] = cir.const #cir.global_view<@_ZTI7Derived> : !cir.ptr<!u8i>
 // AFTER-NEXT:   %[[#OFFSET_HINT:]] = cir.const #cir.int<0> : !s64i
@@ -56,7 +56,7 @@ Derived &ref_cast(Base &b) {
 // AFTER-NEXT:     cir.call @__cxa_bad_cast() : () -> ()
 // AFTER-NEXT:     cir.unreachable
 // AFTER-NEXT:   }
-// AFTER-NEXT:   %{{.+}} = cir.cast(bitcast, %[[#CASTED_PTR]] : !cir.ptr<!void>), !cir.ptr<!ty_22Derived22>
+// AFTER-NEXT:   %{{.+}} = cir.cast(bitcast, %[[#CASTED_PTR]] : !cir.ptr<!void>), !cir.ptr<!ty_Derived>
 //      AFTER: }
 
 void *ptr_cast_to_complete(Base *ptr) {
@@ -64,18 +64,18 @@ void *ptr_cast_to_complete(Base *ptr) {
 }
 
 // BEFORE: cir.func @_Z20ptr_cast_to_completeP4Base
-// BEFORE:   %{{.+}} = cir.dyn_cast(ptr, %{{.+}} : !cir.ptr<!ty_22Base22>) -> !cir.ptr<!void>
+// BEFORE:   %{{.+}} = cir.dyn_cast(ptr, %{{.+}} : !cir.ptr<!ty_Base>) -> !cir.ptr<!void>
 // BEFORE: }
 
 //      AFTER: cir.func @_Z20ptr_cast_to_completeP4Base
-//      AFTER:   %[[#SRC:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_22Base22>>, !cir.ptr<!ty_22Base22>
-// AFTER-NEXT:   %[[#SRC_IS_NOT_NULL:]] = cir.cast(ptr_to_bool, %[[#SRC]] : !cir.ptr<!ty_22Base22>), !cir.bool
+//      AFTER:   %[[#SRC:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!ty_Base>>, !cir.ptr<!ty_Base>
+// AFTER-NEXT:   %[[#SRC_IS_NOT_NULL:]] = cir.cast(ptr_to_bool, %[[#SRC]] : !cir.ptr<!ty_Base>), !cir.bool
 // AFTER-NEXT:   %{{.+}} = cir.ternary(%[[#SRC_IS_NOT_NULL]], true {
-// AFTER-NEXT:     %[[#VPTR_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_22Base22>), !cir.ptr<!cir.ptr<!s64i>>
+// AFTER-NEXT:     %[[#VPTR_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_Base>), !cir.ptr<!cir.ptr<!s64i>>
 // AFTER-NEXT:     %[[#VPTR:]] = cir.load %[[#VPTR_PTR]] : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
 // AFTER-NEXT:     %[[#BASE_OFFSET_PTR:]] = cir.vtable.address_point( %[[#VPTR]] : !cir.ptr<!s64i>, vtable_index = 0, address_point_index = -2) : !cir.ptr<!s64i>
 // AFTER-NEXT:     %[[#BASE_OFFSET:]] = cir.load align(8) %[[#BASE_OFFSET_PTR]] : !cir.ptr<!s64i>, !s64i
-// AFTER-NEXT:     %[[#SRC_BYTES_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_22Base22>), !cir.ptr<!u8i>
+// AFTER-NEXT:     %[[#SRC_BYTES_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!ty_Base>), !cir.ptr<!u8i>
 // AFTER-NEXT:     %[[#DST_BYTES_PTR:]] = cir.ptr_stride(%[[#SRC_BYTES_PTR]] : !cir.ptr<!u8i>, %[[#BASE_OFFSET]] : !s64i), !cir.ptr<!u8i>
 // AFTER-NEXT:     %[[#CASTED_PTR:]] = cir.cast(bitcast, %[[#DST_BYTES_PTR]] : !cir.ptr<!u8i>), !cir.ptr<!void>
 // AFTER-NEXT:     cir.yield %[[#CASTED_PTR]] : !cir.ptr<!void>
diff --git a/clang/test/CIR/CodeGen/evaluate-expr.c b/clang/test/CIR/CodeGen/evaluate-expr.c
index 101f423c8e14..4b7146622dbf 100644
--- a/clang/test/CIR/CodeGen/evaluate-expr.c
+++ b/clang/test/CIR/CodeGen/evaluate-expr.c
@@ -25,7 +25,7 @@ void bar() {
 }
 // CHECK:  cir.func no_proto @bar()
 // CHECK:    [[ALLOC:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
-// CHECK:    {{%.*}} = cir.get_global @s : !cir.ptr<!ty_22S22>
+// CHECK:    {{%.*}} = cir.get_global @s : !cir.ptr<!ty_S>
 // CHECK:    [[CONST:%.*]] = cir.const #cir.int<0> : !s32i
 // CHECK:    cir.store [[CONST]], [[ALLOC]] : !s32i, !cir.ptr<!s32i>
 // CHECK:    cir.return
diff --git a/clang/test/CIR/CodeGen/fun-ptr.c b/clang/test/CIR/CodeGen/fun-ptr.c
index 3dba4ffb6978..e66b7dd0f0b1 100644
--- a/clang/test/CIR/CodeGen/fun-ptr.c
+++ b/clang/test/CIR/CodeGen/fun-ptr.c
@@ -17,25 +17,25 @@ typedef struct A {
   fun_typ fun;
 } A;
 
-// CIR: !ty_22A22 = !cir.struct<struct "A" {!cir.ptr<!cir.func<!cir.int<s, 32> (!cir.ptr<!cir.struct<struct "A">>)>>} #cir.record.decl.ast>
+// CIR: !ty_A = !cir.struct<struct "A" {!cir.ptr<!cir.func<!cir.int<s, 32> (!cir.ptr<!cir.struct<struct "A">>)>>} #cir.record.decl.ast>
 A a = {(fun_typ)0};
 
 int extract_a(Data* d) {
     return d->a;
 }
 
-// CIR: cir.func {{@.*foo.*}}(%arg0: !cir.ptr<!ty_22Data22>
-// CIR:   [[TMP0:%.*]] = cir.alloca !cir.ptr<!ty_22Data22>, !cir.ptr<!cir.ptr<!ty_22Data22>>, ["d", init]
+// CIR: cir.func {{@.*foo.*}}(%arg0: !cir.ptr<!ty_Data>
+// CIR:   [[TMP0:%.*]] = cir.alloca !cir.ptr<!ty_Data>, !cir.ptr<!cir.ptr<!ty_Data>>, ["d", init]
 // CIR:   [[TMP1:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR:   [[TMP2:%.*]] = cir.alloca !cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22Data22>)>>, !cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22Data22>)>>>, ["f", init]
-// CIR:   cir.store %arg0, [[TMP0]] : !cir.ptr<!ty_22Data22>, !cir.ptr<!cir.ptr<!ty_22Data22>>
-// CIR:   [[TMP3:%.*]] = cir.const #cir.ptr<null> : !cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22Data22>)>>
-// CIR:   cir.store [[TMP3]], [[TMP2]] : !cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22Data22>)>>, !cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22Data22>)>>>
-// CIR:   [[TMP4:%.*]] = cir.get_global {{@.*extract_a.*}} : !cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22Data22>)>>
-// CIR:   cir.store [[TMP4]], [[TMP2]] : !cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22Data22>)>>, !cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22Data22>)>>>
-// CIR:   [[TMP5:%.*]] = cir.load [[TMP2]] : !cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22Data22>)>>>, !cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22Data22>)>>
-// CIR:   [[TMP6:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!ty_22Data22>>, !cir.ptr<!ty_22Data22>
-// CIR:   [[TMP7:%.*]] = cir.call [[TMP5]]([[TMP6]]) : (!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_22Data22>)>>, !cir.ptr<!ty_22Data22>) -> !s32i
+// CIR:   [[TMP2:%.*]] = cir.alloca !cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_Data>)>>, !cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_Data>)>>>, ["f", init]
+// CIR:   cir.store %arg0, [[TMP0]] : !cir.ptr<!ty_Data>, !cir.ptr<!cir.ptr<!ty_Data>>
+// CIR:   [[TMP3:%.*]] = cir.const #cir.ptr<null> : !cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_Data>)>>
+// CIR:   cir.store [[TMP3]], [[TMP2]] : !cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_Data>)>>, !cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_Data>)>>>
+// CIR:   [[TMP4:%.*]] = cir.get_global {{@.*extract_a.*}} : !cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_Data>)>>
+// CIR:   cir.store [[TMP4]], [[TMP2]] : !cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_Data>)>>, !cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_Data>)>>>
+// CIR:   [[TMP5:%.*]] = cir.load [[TMP2]] : !cir.ptr<!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_Data>)>>>, !cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_Data>)>>
+// CIR:   [[TMP6:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!ty_Data>>, !cir.ptr<!ty_Data>
+// CIR:   [[TMP7:%.*]] = cir.call [[TMP5]]([[TMP6]]) : (!cir.ptr<!cir.func<!s32i (!cir.ptr<!ty_Data>)>>, !cir.ptr<!ty_Data>) -> !s32i
 // CIR:   cir.store [[TMP7]], [[TMP1]] : !s32i, !cir.ptr<!s32i>
 
 // LLVM: define dso_local i32 {{@.*foo.*}}(ptr %0)
diff --git a/clang/test/CIR/CodeGen/globals-neg-index-array.c b/clang/test/CIR/CodeGen/globals-neg-index-array.c
index 609e8f59e087..7f7a80ea2c9e 100644
--- a/clang/test/CIR/CodeGen/globals-neg-index-array.c
+++ b/clang/test/CIR/CodeGen/globals-neg-index-array.c
@@ -14,7 +14,7 @@ struct __attribute__((packed)) PackedStruct {
 };
 struct PackedStruct packed[10];
 char *packed_element = &(packed[-2].a3);
-// CHECK: cir.global  external @packed = #cir.zero : !cir.array<!ty_22PackedStruct22 x 10> {alignment = 16 : i64} loc(#loc5)
+// CHECK: cir.global  external @packed = #cir.zero : !cir.array<!ty_PackedStruct x 10> {alignment = 16 : i64} loc(#loc5)
 // CHECK: cir.global  external @packed_element = #cir.global_view<@packed, [-2 : i32, 2 : i32]>
 // LLVM: @packed = global [10 x %struct.PackedStruct] zeroinitializer
 // LLVM: @packed_element = global ptr getelementptr inbounds ([10 x %struct.PackedStruct], ptr @packed, i32 -2, i32 2)
diff --git a/clang/test/CIR/CodeGen/globals.c b/clang/test/CIR/CodeGen/globals.c
index 6548bb161cdb..d73e136e2f0f 100644
--- a/clang/test/CIR/CodeGen/globals.c
+++ b/clang/test/CIR/CodeGen/globals.c
@@ -57,25 +57,25 @@ const int i = 12;
 int i2 = i;
 struct { int i; } i3 = {i};
 // CHECK: cir.global external @i2 = #cir.int<12> : !s32i
-// CHECK: cir.global external @i3 = #cir.const_struct<{#cir.int<12> : !s32i}> : !ty_22anon2E722
+// CHECK: cir.global external @i3 = #cir.const_struct<{#cir.int<12> : !s32i}> : !ty_anon2E7_
 
 int a[10][10][10];
 int *a2 = &a[3][0][8];
 struct { int *p; } a3 = {&a[3][0][8]};
 // CHECK: cir.global external @a2 = #cir.global_view<@a, [3 : i32, 0 : i32, 8 : i32]> : !cir.ptr<!s32i>
-// CHECK: cir.global external @a3 = #cir.const_struct<{#cir.global_view<@a, [3 : i32, 0 : i32, 8 : i32]> : !cir.ptr<!s32i>}> : !ty_22anon2E922
+// CHECK: cir.global external @a3 = #cir.const_struct<{#cir.global_view<@a, [3 : i32, 0 : i32, 8 : i32]> : !cir.ptr<!s32i>}> : !ty_anon2E9_
 
 int p[10];
 int *p1 = &p[0];
 struct { int *x; } p2 = {&p[0]};
 // CHECK: cir.global external @p1 = #cir.global_view<@p> : !cir.ptr<!s32i>
-// CHECK: cir.global external @p2 = #cir.const_struct<{#cir.global_view<@p> : !cir.ptr<!s32i>}> : !ty_22anon2E1122
+// CHECK: cir.global external @p2 = #cir.const_struct<{#cir.global_view<@p> : !cir.ptr<!s32i>}> : !ty_anon2E11_
 
 int q[10];
 int *q1 = q;
 struct { int *x; } q2 = {q};
 // CHECK: cir.global external @q1 = #cir.global_view<@q> : !cir.ptr<!s32i>
-// CHECK: cir.global external @q2 = #cir.const_struct<{#cir.global_view<@q> : !cir.ptr<!s32i>}> : !ty_22anon2E1322
+// CHECK: cir.global external @q2 = #cir.const_struct<{#cir.global_view<@q> : !cir.ptr<!s32i>}> : !ty_anon2E13_
 
 int foo() {
     extern int optind;
diff --git a/clang/test/CIR/CodeGen/lambda.cpp b/clang/test/CIR/CodeGen/lambda.cpp
index 7f243167dff4..74ecfc07bdf1 100644
--- a/clang/test/CIR/CodeGen/lambda.cpp
+++ b/clang/test/CIR/CodeGen/lambda.cpp
@@ -6,13 +6,13 @@ void fn() {
   a();
 }
 
-//      CHECK: !ty_22anon2E222 = !cir.struct<class "anon.2" {!cir.int<u, 8>}>
+//      CHECK: !ty_anon2E2_ = !cir.struct<class "anon.2" {!cir.int<u, 8>}>
 //  CHECK-DAG: module
 
 //      CHECK: cir.func lambda internal private @_ZZ2fnvENK3$_0clEv{{.*}}) extra
 
 //      CHECK:   cir.func @_Z2fnv()
-// CHECK-NEXT:     %0 = cir.alloca !ty_22anon2E222, !cir.ptr<!ty_22anon2E222>, ["a"]
+// CHECK-NEXT:     %0 = cir.alloca !ty_anon2E2_, !cir.ptr<!ty_anon2E2_>, ["a"]
 //      CHECK:   cir.call @_ZZ2fnvENK3$_0clEv
 
 void l0() {
@@ -23,15 +23,15 @@ void l0() {
 
 // CHECK: cir.func lambda internal private @_ZZ2l0vENK3$_0clEv({{.*}}) extra
 
-// CHECK: %0 = cir.alloca !cir.ptr<!ty_22anon2E422>, !cir.ptr<!cir.ptr<!ty_22anon2E422>>, ["this", init] {alignment = 8 : i64}
-// CHECK: cir.store %arg0, %0 : !cir.ptr<!ty_22anon2E422>, !cir.ptr<!cir.ptr<!ty_22anon2E422>>
-// CHECK: %1 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22anon2E422>>, !cir.ptr<!ty_22anon2E422>
-// CHECK: %2 = cir.get_member %1[0] {name = "i"} : !cir.ptr<!ty_22anon2E422> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK: %0 = cir.alloca !cir.ptr<!ty_anon2E4_>, !cir.ptr<!cir.ptr<!ty_anon2E4_>>, ["this", init] {alignment = 8 : i64}
+// CHECK: cir.store %arg0, %0 : !cir.ptr<!ty_anon2E4_>, !cir.ptr<!cir.ptr<!ty_anon2E4_>>
+// CHECK: %1 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_anon2E4_>>, !cir.ptr<!ty_anon2E4_>
+// CHECK: %2 = cir.get_member %1[0] {name = "i"} : !cir.ptr<!ty_anon2E4_> -> !cir.ptr<!cir.ptr<!s32i>>
 // CHECK: %3 = cir.load %2 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CHECK: %4 = cir.load %3 : !cir.ptr<!s32i>, !s32i
 // CHECK: %5 = cir.const #cir.int<1> : !s32i
 // CHECK: %6 = cir.binop(add, %4, %5) nsw : !s32i
-// CHECK: %7 = cir.get_member %1[0] {name = "i"} : !cir.ptr<!ty_22anon2E422> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK: %7 = cir.get_member %1[0] {name = "i"} : !cir.ptr<!ty_anon2E4_> -> !cir.ptr<!cir.ptr<!s32i>>
 // CHECK: %8 = cir.load %7 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CHECK: cir.store %6, %8 : !s32i, !cir.ptr<!s32i>
 
@@ -45,15 +45,15 @@ auto g() {
   };
 }
 
-// CHECK: cir.func @_Z1gv() -> !ty_22anon2E622
-// CHECK: %0 = cir.alloca !ty_22anon2E622, !cir.ptr<!ty_22anon2E622>, ["__retval"] {alignment = 8 : i64}
+// CHECK: cir.func @_Z1gv() -> !ty_anon2E6_
+// CHECK: %0 = cir.alloca !ty_anon2E6_, !cir.ptr<!ty_anon2E6_>, ["__retval"] {alignment = 8 : i64}
 // CHECK: %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
 // CHECK: %2 = cir.const #cir.int<12> : !s32i
 // CHECK: cir.store %2, %1 : !s32i, !cir.ptr<!s32i>
-// CHECK: %3 = cir.get_member %0[0] {name = "i"} : !cir.ptr<!ty_22anon2E622> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK: %3 = cir.get_member %0[0] {name = "i"} : !cir.ptr<!ty_anon2E6_> -> !cir.ptr<!cir.ptr<!s32i>>
 // CHECK: cir.store %1, %3 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
-// CHECK: %4 = cir.load %0 : !cir.ptr<!ty_22anon2E622>, !ty_22anon2E622
-// CHECK: cir.return %4 : !ty_22anon2E622
+// CHECK: %4 = cir.load %0 : !cir.ptr<!ty_anon2E6_>, !ty_anon2E6_
+// CHECK: cir.return %4 : !ty_anon2E6_
 
 auto g2() {
   int i = 12;
@@ -65,15 +65,15 @@ auto g2() {
 }
 
 // Should be same as above because of NRVO
-// CHECK: cir.func @_Z2g2v() -> !ty_22anon2E822
-// CHECK-NEXT: %0 = cir.alloca !ty_22anon2E822, !cir.ptr<!ty_22anon2E822>, ["__retval", init] {alignment = 8 : i64}
+// CHECK: cir.func @_Z2g2v() -> !ty_anon2E8_
+// CHECK-NEXT: %0 = cir.alloca !ty_anon2E8_, !cir.ptr<!ty_anon2E8_>, ["__retval", init] {alignment = 8 : i64}
 // CHECK-NEXT: %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
 // CHECK-NEXT: %2 = cir.const #cir.int<12> : !s32i
 // CHECK-NEXT: cir.store %2, %1 : !s32i, !cir.ptr<!s32i>
-// CHECK-NEXT: %3 = cir.get_member %0[0] {name = "i"} : !cir.ptr<!ty_22anon2E822> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK-NEXT: %3 = cir.get_member %0[0] {name = "i"} : !cir.ptr<!ty_anon2E8_> -> !cir.ptr<!cir.ptr<!s32i>>
 // CHECK-NEXT: cir.store %1, %3 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
-// CHECK-NEXT: %4 = cir.load %0 : !cir.ptr<!ty_22anon2E822>, !ty_22anon2E822
-// CHECK-NEXT: cir.return %4 : !ty_22anon2E822
+// CHECK-NEXT: %4 = cir.load %0 : !cir.ptr<!ty_anon2E8_>, !ty_anon2E8_
+// CHECK-NEXT: cir.return %4 : !ty_anon2E8_
 
 int f() {
   return g2()();
@@ -82,10 +82,10 @@ int f() {
 //      CHECK: cir.func @_Z1fv() -> !s32i
 // CHECK-NEXT:   %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
 // CHECK-NEXT:   cir.scope {
-// CHECK-NEXT:     %2 = cir.alloca !ty_22anon2E822, !cir.ptr<!ty_22anon2E822>, ["ref.tmp0"] {alignment = 8 : i64}
-// CHECK-NEXT:     %3 = cir.call @_Z2g2v() : () -> !ty_22anon2E822
-// CHECK-NEXT:     cir.store %3, %2 : !ty_22anon2E822, !cir.ptr<!ty_22anon2E822>
-// CHECK-NEXT:     %4 = cir.call @_ZZ2g2vENK3$_0clEv(%2) : (!cir.ptr<!ty_22anon2E822>) -> !s32i
+// CHECK-NEXT:     %2 = cir.alloca !ty_anon2E8_, !cir.ptr<!ty_anon2E8_>, ["ref.tmp0"] {alignment = 8 : i64}
+// CHECK-NEXT:     %3 = cir.call @_Z2g2v() : () -> !ty_anon2E8_
+// CHECK-NEXT:     cir.store %3, %2 : !ty_anon2E8_, !cir.ptr<!ty_anon2E8_>
+// CHECK-NEXT:     %4 = cir.call @_ZZ2g2vENK3$_0clEv(%2) : (!cir.ptr<!ty_anon2E8_>) -> !s32i
 // CHECK-NEXT:     cir.store %4, %0 : !s32i, !cir.ptr<!s32i>
 // CHECK-NEXT:   }
 // CHECK-NEXT:   %1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
@@ -114,8 +114,8 @@ int g3() {
 
 // 1. Use `operator int (*)(int const&)()` to retrieve the fnptr to `__invoke()`.
 // CHECK:     %3 = cir.scope {
-// CHECK:       %7 = cir.alloca !ty_22anon2E1122, !cir.ptr<!ty_22anon2E1122>, ["ref.tmp0"] {alignment = 1 : i64}
-// CHECK:       %8 = cir.call @_ZZ2g3vENK3$_0cvPFiRKiEEv(%7) : (!cir.ptr<!ty_22anon2E1122>) -> !cir.ptr<!cir.func<!s32i (!cir.ptr<!s32i>)>>
+// CHECK:       %7 = cir.alloca !ty_anon2E11_, !cir.ptr<!ty_anon2E11_>, ["ref.tmp0"] {alignment = 1 : i64}
+// CHECK:       %8 = cir.call @_ZZ2g3vENK3$_0cvPFiRKiEEv(%7) : (!cir.ptr<!ty_anon2E11_>) -> !cir.ptr<!cir.func<!s32i (!cir.ptr<!s32i>)>>
 // CHECK:       %9 = cir.unary(plus, %8) : !cir.ptr<!cir.func<!s32i (!cir.ptr<!s32i>)>>, !cir.ptr<!cir.func<!s32i (!cir.ptr<!s32i>)>>
 // CHECK:       cir.yield %9 : !cir.ptr<!cir.func<!s32i (!cir.ptr<!s32i>)>>
 // CHECK:     }
diff --git a/clang/test/CIR/CodeGen/libcall.cpp b/clang/test/CIR/CodeGen/libcall.cpp
index 8bc469e94368..17d2e7912833 100644
--- a/clang/test/CIR/CodeGen/libcall.cpp
+++ b/clang/test/CIR/CodeGen/libcall.cpp
@@ -59,5 +59,5 @@ void t(const char* fmt, ...) {
 
 // CHECK: %10 = cir.load %1 : !cir.ptr<!u64i>, !u64i
 // CHECK: %11 = cir.load %3 : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
-// CHECK: %12 = cir.load %4 : !cir.ptr<!cir.ptr<!ty_22__va_list_tag22>>, !cir.ptr<!ty_22__va_list_tag22>
+// CHECK: %12 = cir.load %4 : !cir.ptr<!cir.ptr<!ty___va_list_tag>>, !cir.ptr<!ty___va_list_tag>
 // CHECK: %13 = cir.call @__vsnprintf_chk(%6, %8, %9, %10, %11, %12)
diff --git a/clang/test/CIR/CodeGen/lvalue-refs.cpp b/clang/test/CIR/CodeGen/lvalue-refs.cpp
index c4d1866d0291..f1e6dd2fed2a 100644
--- a/clang/test/CIR/CodeGen/lvalue-refs.cpp
+++ b/clang/test/CIR/CodeGen/lvalue-refs.cpp
@@ -6,8 +6,8 @@ struct String {
 
 void split(String &S) {}
 
-// CHECK: cir.func @_Z5splitR6String(%arg0: !cir.ptr<!ty_22String22>
-// CHECK:     %0 = cir.alloca !cir.ptr<!ty_22String22>, !cir.ptr<!cir.ptr<!ty_22String22>>, ["S", init]
+// CHECK: cir.func @_Z5splitR6String(%arg0: !cir.ptr<!ty_String>
+// CHECK:     %0 = cir.alloca !cir.ptr<!ty_String>, !cir.ptr<!cir.ptr<!ty_String>>, ["S", init]
 
 void foo() {
   String s;
@@ -15,5 +15,5 @@ void foo() {
 }
 
 // CHECK: cir.func @_Z3foov()
-// CHECK:     %0 = cir.alloca !ty_22String22, !cir.ptr<!ty_22String22>, ["s"]
-// CHECK:     cir.call @_Z5splitR6String(%0) : (!cir.ptr<!ty_22String22>) -> ()
+// CHECK:     %0 = cir.alloca !ty_String, !cir.ptr<!ty_String>, ["s"]
+// CHECK:     cir.call @_Z5splitR6String(%0) : (!cir.ptr<!ty_String>) -> ()
diff --git a/clang/test/CIR/CodeGen/multi-vtable.cpp b/clang/test/CIR/CodeGen/multi-vtable.cpp
index 619296a0fcd3..ba988a639792 100644
--- a/clang/test/CIR/CodeGen/multi-vtable.cpp
+++ b/clang/test/CIR/CodeGen/multi-vtable.cpp
@@ -34,13 +34,13 @@ int main() {
 // CIR: ![[VTableTypeMother:ty_.*]] = !cir.struct<struct  {!cir.array<!cir.ptr<!cir.int<u, 8>> x 4>}>
 // CIR: ![[VTableTypeFather:ty_.*]] = !cir.struct<struct  {!cir.array<!cir.ptr<!cir.int<u, 8>> x 3>}>
 // CIR: ![[VTableTypeChild:ty_.*]] = !cir.struct<struct  {!cir.array<!cir.ptr<!cir.int<u, 8>> x 4>, !cir.array<!cir.ptr<!cir.int<u, 8>> x 3>}>
-// CIR: !ty_22Father22 = !cir.struct<class "Father" {!cir.ptr<!cir.ptr<!cir.func<!cir.int<u, 32> ()>>>} #cir.record.decl.ast>
-// CIR: !ty_22Mother22 = !cir.struct<class "Mother" {!cir.ptr<!cir.ptr<!cir.func<!cir.int<u, 32> ()>>>} #cir.record.decl.ast>
-// CIR: !ty_22Child22 = !cir.struct<class "Child" {!cir.struct<class "Mother" {!cir.ptr<!cir.ptr<!cir.func<!cir.int<u, 32> ()>>>} #cir.record.decl.ast>, !cir.struct<class "Father" {!cir.ptr<!cir.ptr<!cir.func<!cir.int<u, 32> ()>>>} #cir.record.decl.ast>} #cir.record.decl.ast>
+// CIR: !ty_Father = !cir.struct<class "Father" {!cir.ptr<!cir.ptr<!cir.func<!cir.int<u, 32> ()>>>} #cir.record.decl.ast>
+// CIR: !ty_Mother = !cir.struct<class "Mother" {!cir.ptr<!cir.ptr<!cir.func<!cir.int<u, 32> ()>>>} #cir.record.decl.ast>
+// CIR: !ty_Child = !cir.struct<class "Child" {!cir.struct<class "Mother" {!cir.ptr<!cir.ptr<!cir.func<!cir.int<u, 32> ()>>>} #cir.record.decl.ast>, !cir.struct<class "Father" {!cir.ptr<!cir.ptr<!cir.func<!cir.int<u, 32> ()>>>} #cir.record.decl.ast>} #cir.record.decl.ast>
 
-// CIR: cir.func linkonce_odr @_ZN6MotherC2Ev(%arg0: !cir.ptr<!ty_22Mother22>
+// CIR: cir.func linkonce_odr @_ZN6MotherC2Ev(%arg0: !cir.ptr<!ty_Mother>
 // CIR:   %{{[0-9]+}} = cir.vtable.address_point(@_ZTV6Mother, vtable_index = 0, address_point_index = 2) : !cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>
-// CIR:   %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!ty_22Mother22>), !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>>
+// CIR:   %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!ty_Mother>), !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>>
 // CIR:   cir.store %2, %{{[0-9]+}} : !cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>>
 // CIR:   cir.return
 // CIR: }
@@ -50,14 +50,14 @@ int main() {
 // LLVM-DAG:   ret void
 // LLVM-DAG: }
 
-// CIR: cir.func linkonce_odr @_ZN5ChildC2Ev(%arg0: !cir.ptr<!ty_22Child22>
+// CIR: cir.func linkonce_odr @_ZN5ChildC2Ev(%arg0: !cir.ptr<!ty_Child>
 // CIR:   %{{[0-9]+}} = cir.vtable.address_point(@_ZTV5Child, vtable_index = 0, address_point_index = 2) : !cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>
-// CIR:   %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!ty_22Child22>), !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>>
+// CIR:   %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!ty_Child>), !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>>
 // CIR:   cir.store %{{[0-9]+}}, %{{[0-9]+}} : !cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>>
 // CIR:   %{{[0-9]+}} = cir.vtable.address_point(@_ZTV5Child, vtable_index = 1, address_point_index = 2) : !cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>
 // CIR:   %{{[0-9]+}} = cir.const #cir.int<8> : !s64i
-// CIR:   %{{[0-9]+}} = cir.ptr_stride(%{{[0-9]+}} : !cir.ptr<!ty_22Child22>, %{{[0-9]+}} : !s64i), !cir.ptr<!ty_22Child22>
-// CIR:   %11 = cir.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!ty_22Child22>), !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>>
+// CIR:   %{{[0-9]+}} = cir.ptr_stride(%{{[0-9]+}} : !cir.ptr<!ty_Child>, %{{[0-9]+}} : !s64i), !cir.ptr<!ty_Child>
+// CIR:   %11 = cir.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!ty_Child>), !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>>
 // CIR:   cir.store %{{[0-9]+}}, %{{[0-9]+}} : !cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<!u32i ()>>>>
 // CIR:   cir.return
 // CIR: }
@@ -75,9 +75,9 @@ int main() {
 
 // CIR: cir.func @main() -> !s32i extra(#fn_attr) {
 
-// CIR:   %{{[0-9]+}} = cir.vtable.address_point( %{{[0-9]+}} : !cir.ptr<!cir.ptr<!cir.func<!void (!cir.ptr<!ty_22Mother22>)>>>, vtable_index = 0, address_point_index = 0) : !cir.ptr<!cir.ptr<!cir.func<!void (!cir.ptr<!ty_22Mother22>)>>>
+// CIR:   %{{[0-9]+}} = cir.vtable.address_point( %{{[0-9]+}} : !cir.ptr<!cir.ptr<!cir.func<!void (!cir.ptr<!ty_Mother>)>>>, vtable_index = 0, address_point_index = 0) : !cir.ptr<!cir.ptr<!cir.func<!void (!cir.ptr<!ty_Mother>)>>>
 
-// CIR:   %{{[0-9]+}} = cir.vtable.address_point( %{{[0-9]+}} : !cir.ptr<!cir.ptr<!cir.func<!void (!cir.ptr<!ty_22Child22>)>>>, vtable_index = 0, address_point_index = 0) : !cir.ptr<!cir.ptr<!cir.func<!void (!cir.ptr<!ty_22Child22>)>>>
+// CIR:   %{{[0-9]+}} = cir.vtable.address_point( %{{[0-9]+}} : !cir.ptr<!cir.ptr<!cir.func<!void (!cir.ptr<!ty_Child>)>>>, vtable_index = 0, address_point_index = 0) : !cir.ptr<!cir.ptr<!cir.func<!void (!cir.ptr<!ty_Child>)>>>
 
 // CIR: }
 
diff --git a/clang/test/CIR/CodeGen/new.cpp b/clang/test/CIR/CodeGen/new.cpp
index 4f7226376ddd..acf7df22d5a9 100644
--- a/clang/test/CIR/CodeGen/new.cpp
+++ b/clang/test/CIR/CodeGen/new.cpp
@@ -14,19 +14,19 @@ void m(int a, int b) {
 // CHECK: cir.func linkonce_odr @_ZSt11make_sharedI1SJRiS1_EESt10shared_ptrIT_EDpOT0_(
 // CHECK:   %0 = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["args", init] {alignment = 8 : i64}
 // CHECK:   %1 = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["args", init] {alignment = 8 : i64}
-// CHECK:   %2 = cir.alloca !ty_22std3A3Ashared_ptr3CS3E22, !cir.ptr<!ty_22std3A3Ashared_ptr3CS3E22>, ["__retval"] {alignment = 1 : i64}
+// CHECK:   %2 = cir.alloca !ty_std3A3Ashared_ptr3CS3E, !cir.ptr<!ty_std3A3Ashared_ptr3CS3E>, ["__retval"] {alignment = 1 : i64}
 // CHECK:   cir.store %arg0, %0 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
 // CHECK:   cir.store %arg1, %1 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
 // CHECK:   cir.scope {
 // CHECK:     %4 = cir.const #cir.int<1> : !u64i
 // CHECK:     %5 = cir.call @_Znwm(%4) : (!u64i) -> !cir.ptr<!void>
-// CHECK:     %6 = cir.cast(bitcast, %5 : !cir.ptr<!void>), !cir.ptr<!ty_22S22>
+// CHECK:     %6 = cir.cast(bitcast, %5 : !cir.ptr<!void>), !cir.ptr<!ty_S>
 // CHECK:     %7 = cir.load %0 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CHECK:     %8 = cir.load %7 : !cir.ptr<!s32i>, !s32i
 // CHECK:     %9 = cir.load %1 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CHECK:     %10 = cir.load %9 : !cir.ptr<!s32i>, !s32i
-// CHECK:     cir.call @_ZN1SC1Eii(%6, %8, %10) : (!cir.ptr<!ty_22S22>, !s32i, !s32i) -> ()
-// CHECK:     cir.call @_ZNSt10shared_ptrI1SEC1EPS0_(%2, %6) : (!cir.ptr<!ty_22std3A3Ashared_ptr3CS3E22>, !cir.ptr<!ty_22S22>) -> ()
+// CHECK:     cir.call @_ZN1SC1Eii(%6, %8, %10) : (!cir.ptr<!ty_S>, !s32i, !s32i) -> ()
+// CHECK:     cir.call @_ZNSt10shared_ptrI1SEC1EPS0_(%2, %6) : (!cir.ptr<!ty_std3A3Ashared_ptr3CS3E>, !cir.ptr<!ty_S>) -> ()
 // CHECK:   }
 
 class B {
@@ -36,19 +36,19 @@ class B {
   }
 };
 
-// CHECK: cir.func linkonce_odr @_ZN1B9constructEPS_(%arg0: !cir.ptr<!ty_22B22>
-// CHECK:   %0 = cir.alloca !cir.ptr<!ty_22B22>, !cir.ptr<!cir.ptr<!ty_22B22>>, ["this", init] {alignment = 8 : i64}
-// CHECK:   %1 = cir.alloca !cir.ptr<!ty_22B22>, !cir.ptr<!cir.ptr<!ty_22B22>>, ["__p", init] {alignment = 8 : i64}
-// CHECK:   cir.store %arg0, %0 : !cir.ptr<!ty_22B22>, !cir.ptr<!cir.ptr<!ty_22B22>>
-// CHECK:   cir.store %arg1, %1 : !cir.ptr<!ty_22B22>, !cir.ptr<!cir.ptr<!ty_22B22>>
-// CHECK:   %2 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22B22>>, !cir.ptr<!ty_22B22>
+// CHECK: cir.func linkonce_odr @_ZN1B9constructEPS_(%arg0: !cir.ptr<!ty_B>
+// CHECK:   %0 = cir.alloca !cir.ptr<!ty_B>, !cir.ptr<!cir.ptr<!ty_B>>, ["this", init] {alignment = 8 : i64}
+// CHECK:   %1 = cir.alloca !cir.ptr<!ty_B>, !cir.ptr<!cir.ptr<!ty_B>>, ["__p", init] {alignment = 8 : i64}
+// CHECK:   cir.store %arg0, %0 : !cir.ptr<!ty_B>, !cir.ptr<!cir.ptr<!ty_B>>
+// CHECK:   cir.store %arg1, %1 : !cir.ptr<!ty_B>, !cir.ptr<!cir.ptr<!ty_B>>
+// CHECK:   %2 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_B>>, !cir.ptr<!ty_B>
 // CHECK:   %3 = cir.const #cir.int<1> : !u64i
-// CHECK:   %4 = cir.load %1 : !cir.ptr<!cir.ptr<!ty_22B22>>, !cir.ptr<!ty_22B22>
-// CHECK:   %5 = cir.cast(bitcast, %4 : !cir.ptr<!ty_22B22>), !cir.ptr<!void>
-// CHECK:   %6 = cir.cast(bitcast, %5 : !cir.ptr<!void>), !cir.ptr<!ty_22B22>
+// CHECK:   %4 = cir.load %1 : !cir.ptr<!cir.ptr<!ty_B>>, !cir.ptr<!ty_B>
+// CHECK:   %5 = cir.cast(bitcast, %4 : !cir.ptr<!ty_B>), !cir.ptr<!void>
+// CHECK:   %6 = cir.cast(bitcast, %5 : !cir.ptr<!void>), !cir.ptr<!ty_B>
 
 // cir.call @B::B()(%new_placament_ptr)
-// CHECK:   cir.call @_ZN1BC1Ev(%6) : (!cir.ptr<!ty_22B22>) -> ()
+// CHECK:   cir.call @_ZN1BC1Ev(%6) : (!cir.ptr<!ty_B>) -> ()
 // CHECK:   cir.return
 // CHECK: }
 
diff --git a/clang/test/CIR/CodeGen/packed-structs.c b/clang/test/CIR/CodeGen/packed-structs.c
index f3c4cdf72cba..f50fd87168f6 100644
--- a/clang/test/CIR/CodeGen/packed-structs.c
+++ b/clang/test/CIR/CodeGen/packed-structs.c
@@ -20,14 +20,14 @@ typedef struct {
 } __attribute__((aligned(2))) C;
 
 
-// CHECK: !ty_22A22 = !cir.struct<struct "A" packed {!cir.int<s, 32>, !cir.int<s, 8>}>
-// CHECK: !ty_22C22 = !cir.struct<struct "C" packed {!cir.int<s, 32>, !cir.int<s, 8>}>
-// CHECK: !ty_22B22 = !cir.struct<struct "B" packed {!cir.int<s, 32>, !cir.int<s, 8>, !cir.array<!cir.struct<struct "A" packed {!cir.int<s, 32>, !cir.int<s, 8>}> x 6>}>
+// CHECK: !ty_A = !cir.struct<struct "A" packed {!cir.int<s, 32>, !cir.int<s, 8>}>
+// CHECK: !ty_C = !cir.struct<struct "C" packed {!cir.int<s, 32>, !cir.int<s, 8>}>
+// CHECK: !ty_B = !cir.struct<struct "B" packed {!cir.int<s, 32>, !cir.int<s, 8>, !cir.array<!cir.struct<struct "A" packed {!cir.int<s, 32>, !cir.int<s, 8>}> x 6>}>
 
 // CHECK: cir.func {{.*@foo()}}
-// CHECK:  %0 = cir.alloca !ty_22A22, !cir.ptr<!ty_22A22>, ["a"] {alignment = 1 : i64}
-// CHECK:  %1 = cir.alloca !ty_22B22, !cir.ptr<!ty_22B22>, ["b"] {alignment = 1 : i64}
-// CHECK:  %2 = cir.alloca !ty_22C22, !cir.ptr<!ty_22C22>, ["c"] {alignment = 2 : i64}
+// CHECK:  %0 = cir.alloca !ty_A, !cir.ptr<!ty_A>, ["a"] {alignment = 1 : i64}
+// CHECK:  %1 = cir.alloca !ty_B, !cir.ptr<!ty_B>, ["b"] {alignment = 1 : i64}
+// CHECK:  %2 = cir.alloca !ty_C, !cir.ptr<!ty_C>, ["c"] {alignment = 2 : i64}
 void foo() {
     A a;
     B b;
diff --git a/clang/test/CIR/CodeGen/pointer-to-data-member.cpp b/clang/test/CIR/CodeGen/pointer-to-data-member.cpp
index 4bec78f52531..6fa8901333ba 100644
--- a/clang/test/CIR/CodeGen/pointer-to-data-member.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-data-member.cpp
@@ -6,57 +6,57 @@ struct Point {
   int y;
   int z;
 };
-// CHECK-DAG: !ty_22Point22 = !cir.struct<struct "Point" {!cir.int<s, 32>, !cir.int<s, 32>, !cir.int<s, 32>}
+// CHECK-DAG: !ty_Point = !cir.struct<struct "Point" {!cir.int<s, 32>, !cir.int<s, 32>, !cir.int<s, 32>}
 
 struct Incomplete;
-// CHECK-DAG: !ty_22Incomplete22 = !cir.struct<struct "Incomplete" incomplete>
+// CHECK-DAG: !ty_Incomplete = !cir.struct<struct "Incomplete" incomplete>
 
 int Point::*pt_member = &Point::x;
-// CHECK: cir.global external @pt_member = #cir.data_member<0> : !cir.data_member<!s32i in !ty_22Point22>
+// CHECK: cir.global external @pt_member = #cir.data_member<0> : !cir.data_member<!s32i in !ty_Point>
 
 auto test1() -> int Point::* {
   return &Point::y;
 }
-// CHECK: cir.func @_Z5test1v() -> !cir.data_member<!s32i in !ty_22Point22>
-// CHECK:   %{{.+}} = cir.const #cir.data_member<1> : !cir.data_member<!s32i in !ty_22Point22>
+// CHECK: cir.func @_Z5test1v() -> !cir.data_member<!s32i in !ty_Point>
+// CHECK:   %{{.+}} = cir.const #cir.data_member<1> : !cir.data_member<!s32i in !ty_Point>
 // CHECK: }
 
 int test2(const Point &pt, int Point::*member) {
   return pt.*member;
 }
 // CHECK: cir.func @_Z5test2RK5PointMS_i
-// CHECK:   %{{.+}} = cir.get_runtime_member %{{.+}}[%{{.+}} : !cir.data_member<!s32i in !ty_22Point22>] : !cir.ptr<!ty_22Point22> -> !cir.ptr<!s32i>
+// CHECK:   %{{.+}} = cir.get_runtime_member %{{.+}}[%{{.+}} : !cir.data_member<!s32i in !ty_Point>] : !cir.ptr<!ty_Point> -> !cir.ptr<!s32i>
 // CHECK: }
 
 int test3(const Point *pt, int Point::*member) {
   return pt->*member;
 }
 // CHECK: cir.func @_Z5test3PK5PointMS_i
-// CHECK:   %{{.+}} = cir.get_runtime_member %{{.+}}[%{{.+}} : !cir.data_member<!s32i in !ty_22Point22>] : !cir.ptr<!ty_22Point22> -> !cir.ptr<!s32i>
+// CHECK:   %{{.+}} = cir.get_runtime_member %{{.+}}[%{{.+}} : !cir.data_member<!s32i in !ty_Point>] : !cir.ptr<!ty_Point> -> !cir.ptr<!s32i>
 // CHECK: }
 
 auto test4(int Incomplete::*member) -> int Incomplete::* {
   return member;
 }
-// CHECK: cir.func @_Z5test4M10Incompletei(%arg0: !cir.data_member<!s32i in !ty_22Incomplete22> loc({{.+}})) -> !cir.data_member<!s32i in !ty_22Incomplete22>
+// CHECK: cir.func @_Z5test4M10Incompletei(%arg0: !cir.data_member<!s32i in !ty_Incomplete> loc({{.+}})) -> !cir.data_member<!s32i in !ty_Incomplete>
 
 int test5(Incomplete *ic, int Incomplete::*member) {
   return ic->*member;
 }
 // CHECK: cir.func @_Z5test5P10IncompleteMS_i
-// CHECK: %{{.+}} = cir.get_runtime_member %{{.+}}[%{{.+}} : !cir.data_member<!s32i in !ty_22Incomplete22>] : !cir.ptr<!ty_22Incomplete22> -> !cir.ptr<!s32i>
+// CHECK: %{{.+}} = cir.get_runtime_member %{{.+}}[%{{.+}} : !cir.data_member<!s32i in !ty_Incomplete>] : !cir.ptr<!ty_Incomplete> -> !cir.ptr<!s32i>
 // CHECK: }
 
 auto test_null() -> int Point::* {
   return nullptr;
 }
 // CHECK: cir.func @_Z9test_nullv
-// CHECK:   %{{.+}} = cir.const #cir.data_member<null> : !cir.data_member<!s32i in !ty_22Point22>
+// CHECK:   %{{.+}} = cir.const #cir.data_member<null> : !cir.data_member<!s32i in !ty_Point>
 // CHECK: }
 
 auto test_null_incomplete() -> int Incomplete::* {
   return nullptr;
 }
 // CHECK: cir.func @_Z20test_null_incompletev
-// CHECK:   %{{.+}} = cir.const #cir.data_member<null> : !cir.data_member<!s32i in !ty_22Incomplete22>
+// CHECK:   %{{.+}} = cir.const #cir.data_member<null> : !cir.data_member<!s32i in !ty_Incomplete>
 // CHECK: }
diff --git a/clang/test/CIR/CodeGen/pointer-to-member-func.cpp b/clang/test/CIR/CodeGen/pointer-to-member-func.cpp
index 6d226a6875c2..6f8b3363bfa3 100644
--- a/clang/test/CIR/CodeGen/pointer-to-member-func.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-member-func.cpp
@@ -11,24 +11,24 @@ auto make_non_virtual() -> void (Foo::*)(int) {
   return &Foo::m1;
 }
 
-// CHECK-LABEL: cir.func @_Z16make_non_virtualv() -> !cir.method<!cir.func<!void (!s32i)> in !ty_22Foo22>
-//       CHECK:   %{{.+}} = cir.const #cir.method<@_ZN3Foo2m1Ei> : !cir.method<!cir.func<!void (!s32i)> in !ty_22Foo22>
+// CHECK-LABEL: cir.func @_Z16make_non_virtualv() -> !cir.method<!cir.func<!void (!s32i)> in !ty_Foo>
+//       CHECK:   %{{.+}} = cir.const #cir.method<@_ZN3Foo2m1Ei> : !cir.method<!cir.func<!void (!s32i)> in !ty_Foo>
 //       CHECK: }
 
 auto make_virtual() -> void (Foo::*)(int) {
   return &Foo::m3;
 }
 
-// CHECK-LABEL: cir.func @_Z12make_virtualv() -> !cir.method<!cir.func<!void (!s32i)> in !ty_22Foo22>
-//       CHECK:   %{{.+}} = cir.const #cir.method<vtable_offset = 8> : !cir.method<!cir.func<!void (!s32i)> in !ty_22Foo22>
+// CHECK-LABEL: cir.func @_Z12make_virtualv() -> !cir.method<!cir.func<!void (!s32i)> in !ty_Foo>
+//       CHECK:   %{{.+}} = cir.const #cir.method<vtable_offset = 8> : !cir.method<!cir.func<!void (!s32i)> in !ty_Foo>
 //       CHECK: }
 
 auto make_null() -> void (Foo::*)(int) {
   return nullptr;
 }
 
-// CHECK-LABEL: cir.func @_Z9make_nullv() -> !cir.method<!cir.func<!void (!s32i)> in !ty_22Foo22>
-//       CHECK:   %{{.+}} = cir.const #cir.method<null> : !cir.method<!cir.func<!void (!s32i)> in !ty_22Foo22>
+// CHECK-LABEL: cir.func @_Z9make_nullv() -> !cir.method<!cir.func<!void (!s32i)> in !ty_Foo>
+//       CHECK:   %{{.+}} = cir.const #cir.method<null> : !cir.method<!cir.func<!void (!s32i)> in !ty_Foo>
 //       CHECK: }
 
 void call(Foo *obj, void (Foo::*func)(int), int arg) {
@@ -36,7 +36,7 @@ void call(Foo *obj, void (Foo::*func)(int), int arg) {
 }
 
 // CHECK-LABEL: cir.func @_Z4callP3FooMS_FviEi
-//       CHECK:   %[[CALLEE:.+]], %[[THIS:.+]] = cir.get_method %{{.+}}, %{{.+}} : (!cir.method<!cir.func<!void (!s32i)> in !ty_22Foo22>, !cir.ptr<!ty_22Foo22>) -> (!cir.ptr<!cir.func<!void (!cir.ptr<!void>, !s32i)>>, !cir.ptr<!void>)
+//       CHECK:   %[[CALLEE:.+]], %[[THIS:.+]] = cir.get_method %{{.+}}, %{{.+}} : (!cir.method<!cir.func<!void (!s32i)> in !ty_Foo>, !cir.ptr<!ty_Foo>) -> (!cir.ptr<!cir.func<!void (!cir.ptr<!void>, !s32i)>>, !cir.ptr<!void>)
 //  CHECK-NEXT:   %[[#ARG:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
 //  CHECK-NEXT:   cir.call %[[CALLEE]](%[[THIS]], %[[#ARG]]) : (!cir.ptr<!cir.func<!void (!cir.ptr<!void>, !s32i)>>, !cir.ptr<!void>, !s32i) -> ()
 //       CHECK: }
diff --git a/clang/test/CIR/CodeGen/rangefor.cpp b/clang/test/CIR/CodeGen/rangefor.cpp
index 35f8da89312c..5dc724583506 100644
--- a/clang/test/CIR/CodeGen/rangefor.cpp
+++ b/clang/test/CIR/CodeGen/rangefor.cpp
@@ -21,7 +21,7 @@ void init(unsigned numImages) {
   }
 }
 
-// CHECK-DAG: !ty_22triple22 = !cir.struct<struct "triple" {!cir.int<u, 32>, !cir.ptr<!cir.void>, !cir.int<u, 32>}>
+// CHECK-DAG: !ty_triple = !cir.struct<struct "triple" {!cir.int<u, 32>, !cir.ptr<!cir.void>, !cir.int<u, 32>}>
 // CHECK-DAG: ![[VEC:.*]] = !cir.struct<class "std::vector<triple>" {!cir.ptr<!cir.struct<struct "triple" {!cir.int<u, 32>, !cir.ptr<!cir.void>, !cir.int<u, 32>}>>, !cir.ptr<!cir.struct<struct "triple" {!cir.int<u, 32>, !cir.ptr<!cir.void>, !cir.int<u, 32>}>>, !cir.ptr<!cir.struct<struct "triple" {!cir.int<u, 32>, !cir.ptr<!cir.void>, !cir.int<u, 32>}>>}>
 // CHECK-DAG: ![[VEC_IT:.*]] = !cir.struct<struct "__vector_iterator<triple, triple *, triple &>" {!cir.ptr<!cir.struct<struct "triple" {!cir.int<u, 32>, !cir.ptr<!cir.void>, !cir.int<u, 32>}>
 
@@ -36,7 +36,7 @@ void init(unsigned numImages) {
 // CHECK:     %4 = cir.alloca !cir.ptr<![[VEC]]>, !cir.ptr<!cir.ptr<![[VEC]]>>, ["__range1", init] {alignment = 8 : i64}
 // CHECK:     %5 = cir.alloca ![[VEC_IT]], !cir.ptr<![[VEC_IT]]>, ["__begin1", init] {alignment = 8 : i64}
 // CHECK:     %6 = cir.alloca ![[VEC_IT]], !cir.ptr<![[VEC_IT]]>, ["__end1", init] {alignment = 8 : i64}
-// CHECK:     %7 = cir.alloca !cir.ptr<!ty_22triple22>, !cir.ptr<!cir.ptr<!ty_22triple22>>, ["image", init] {alignment = 8 : i64}
+// CHECK:     %7 = cir.alloca !cir.ptr<!ty_triple>, !cir.ptr<!cir.ptr<!ty_triple>>, ["image", init] {alignment = 8 : i64}
 // CHECK:     cir.store %1, %4 : !cir.ptr<![[VEC]]>, !cir.ptr<!cir.ptr<![[VEC]]>>
 // CHECK:     %8 = cir.load %4 : !cir.ptr<!cir.ptr<![[VEC]]>>, !cir.ptr<![[VEC]]>
 // CHECK:     %9 = cir.call @_ZNSt6vectorI6tripleE5beginEv(%8) : (!cir.ptr<![[VEC]]>) -> ![[VEC_IT]]
@@ -48,19 +48,19 @@ void init(unsigned numImages) {
 // CHECK:       %12 = cir.call @_ZNK17__vector_iteratorI6triplePS0_RS0_EneERKS3_(%5, %6) : (!cir.ptr<![[VEC_IT]]>, !cir.ptr<![[VEC_IT]]>) -> !cir.bool
 // CHECK:       cir.condition(%12)
 // CHECK:     } body {
-// CHECK:       %12 = cir.call @_ZNK17__vector_iteratorI6triplePS0_RS0_EdeEv(%5) : (!cir.ptr<![[VEC_IT]]>) -> !cir.ptr<!ty_22triple22>
-// CHECK:       cir.store %12, %7 : !cir.ptr<!ty_22triple22>, !cir.ptr<!cir.ptr<!ty_22triple22>>
+// CHECK:       %12 = cir.call @_ZNK17__vector_iteratorI6triplePS0_RS0_EdeEv(%5) : (!cir.ptr<![[VEC_IT]]>) -> !cir.ptr<!ty_triple>
+// CHECK:       cir.store %12, %7 : !cir.ptr<!ty_triple>, !cir.ptr<!cir.ptr<!ty_triple>>
 // CHECK:       cir.scope {
-// CHECK:         %13 = cir.alloca !ty_22triple22, !cir.ptr<!ty_22triple22>, ["ref.tmp0"] {alignment = 8 : i64}
-// CHECK:         %14 = cir.const #cir.zero : !ty_22triple22
-// CHECK:         cir.store %14, %13 : !ty_22triple22, !cir.ptr<!ty_22triple22>
-// CHECK:         %15 = cir.get_member %13[0] {name = "type"} : !cir.ptr<!ty_22triple22> -> !cir.ptr<!u32i>
+// CHECK:         %13 = cir.alloca !ty_triple, !cir.ptr<!ty_triple>, ["ref.tmp0"] {alignment = 8 : i64}
+// CHECK:         %14 = cir.const #cir.zero : !ty_triple
+// CHECK:         cir.store %14, %13 : !ty_triple, !cir.ptr<!ty_triple>
+// CHECK:         %15 = cir.get_member %13[0] {name = "type"} : !cir.ptr<!ty_triple> -> !cir.ptr<!u32i>
 // CHECK:         %16 = cir.const #cir.int<1000024002> : !u32i
 // CHECK:         cir.store %16, %15 : !u32i, !cir.ptr<!u32i>
-// CHECK:         %17 = cir.get_member %13[1] {name = "next"} : !cir.ptr<!ty_22triple22> -> !cir.ptr<!cir.ptr<!void>>
-// CHECK:         %18 = cir.get_member %13[2] {name = "image"} : !cir.ptr<!ty_22triple22> -> !cir.ptr<!u32i>
-// CHECK:         %19 = cir.load %7 : !cir.ptr<!cir.ptr<!ty_22triple22>>, !cir.ptr<!ty_22triple22>
-// CHECK:         %20 = cir.call @_ZN6tripleaSEOS_(%19, %13) : (!cir.ptr<!ty_22triple22>, !cir.ptr<!ty_22triple22>) -> !cir.ptr<!ty_22triple22>
+// CHECK:         %17 = cir.get_member %13[1] {name = "next"} : !cir.ptr<!ty_triple> -> !cir.ptr<!cir.ptr<!void>>
+// CHECK:         %18 = cir.get_member %13[2] {name = "image"} : !cir.ptr<!ty_triple> -> !cir.ptr<!u32i>
+// CHECK:         %19 = cir.load %7 : !cir.ptr<!cir.ptr<!ty_triple>>, !cir.ptr<!ty_triple>
+// CHECK:         %20 = cir.call @_ZN6tripleaSEOS_(%19, %13) : (!cir.ptr<!ty_triple>, !cir.ptr<!ty_triple>) -> !cir.ptr<!ty_triple>
 // CHECK:       }
 // CHECK:       cir.yield
 // CHECK:     } step {
diff --git a/clang/test/CIR/CodeGen/skip-functions-from-system-headers.cpp b/clang/test/CIR/CodeGen/skip-functions-from-system-headers.cpp
index 96730e748a4c..f48602b87676 100644
--- a/clang/test/CIR/CodeGen/skip-functions-from-system-headers.cpp
+++ b/clang/test/CIR/CodeGen/skip-functions-from-system-headers.cpp
@@ -15,4 +15,4 @@ void test() {
 // CHECK-NOT: cir.func linkonce_odr @_ZN6StringC1EPKc
 
 // CHECK: cir.func @_Z4testv()
-// CHECK:   cir.call @_ZN6StringC1Ev(%0) : (!cir.ptr<!ty_22String22>) -> ()
\ No newline at end of file
+// CHECK:   cir.call @_ZN6StringC1Ev(%0) : (!cir.ptr<!ty_String>) -> ()
\ No newline at end of file
diff --git a/clang/test/CIR/CodeGen/static.cpp b/clang/test/CIR/CodeGen/static.cpp
index e011ed99233d..2ba42118dddb 100644
--- a/clang/test/CIR/CodeGen/static.cpp
+++ b/clang/test/CIR/CodeGen/static.cpp
@@ -17,23 +17,23 @@ static Init __ioinit(true);
 static Init __ioinit2(false);
 
 // BEFORE:      module {{.*}} {
-// BEFORE-NEXT:   cir.func private @_ZN4InitC1Eb(!cir.ptr<!ty_22Init22>, !cir.bool)
-// BEFORE-NEXT:   cir.func private @_ZN4InitD1Ev(!cir.ptr<!ty_22Init22>)
-// BEFORE-NEXT:   cir.global "private" internal dsolocal @_ZL8__ioinit = ctor : !ty_22Init22 {
-// BEFORE-NEXT:     %0 = cir.get_global @_ZL8__ioinit : !cir.ptr<!ty_22Init22>
+// BEFORE-NEXT:   cir.func private @_ZN4InitC1Eb(!cir.ptr<!ty_Init>, !cir.bool)
+// BEFORE-NEXT:   cir.func private @_ZN4InitD1Ev(!cir.ptr<!ty_Init>)
+// BEFORE-NEXT:   cir.global "private" internal dsolocal @_ZL8__ioinit = ctor : !ty_Init {
+// BEFORE-NEXT:     %0 = cir.get_global @_ZL8__ioinit : !cir.ptr<!ty_Init>
 // BEFORE-NEXT:     %1 = cir.const #true
-// BEFORE-NEXT:     cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr<!ty_22Init22>, !cir.bool) -> ()
+// BEFORE-NEXT:     cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr<!ty_Init>, !cir.bool) -> ()
 // BEFORE-NEXT:   } dtor {
-// BEFORE-NEXT:      %0 = cir.get_global @_ZL8__ioinit : !cir.ptr<!ty_22Init22>
-// BEFORE-NEXT:      cir.call @_ZN4InitD1Ev(%0) : (!cir.ptr<!ty_22Init22>) -> ()
+// BEFORE-NEXT:      %0 = cir.get_global @_ZL8__ioinit : !cir.ptr<!ty_Init>
+// BEFORE-NEXT:      cir.call @_ZN4InitD1Ev(%0) : (!cir.ptr<!ty_Init>) -> ()
 // BEFORE-NEXT:   } {alignment = 1 : i64, ast = #cir.var.decl.ast}
-// BEFORE:        cir.global "private" internal dsolocal @_ZL9__ioinit2 = ctor : !ty_22Init22 {
-// BEFORE-NEXT:     %0 = cir.get_global @_ZL9__ioinit2 : !cir.ptr<!ty_22Init22>
+// BEFORE:        cir.global "private" internal dsolocal @_ZL9__ioinit2 = ctor : !ty_Init {
+// BEFORE-NEXT:     %0 = cir.get_global @_ZL9__ioinit2 : !cir.ptr<!ty_Init>
 // BEFORE-NEXT:     %1 = cir.const #false
-// BEFORE-NEXT:     cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr<!ty_22Init22>, !cir.bool) -> ()
+// BEFORE-NEXT:     cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr<!ty_Init>, !cir.bool) -> ()
 // BEFORE-NEXT:   } dtor  {
-// BEFORE-NEXT:     %0 = cir.get_global @_ZL9__ioinit2 : !cir.ptr<!ty_22Init22>
-// BEFORE-NEXT:     cir.call @_ZN4InitD1Ev(%0) : (!cir.ptr<!ty_22Init22>) -> ()
+// BEFORE-NEXT:     %0 = cir.get_global @_ZL9__ioinit2 : !cir.ptr<!ty_Init>
+// BEFORE-NEXT:     cir.call @_ZN4InitD1Ev(%0) : (!cir.ptr<!ty_Init>) -> ()
 // BEFORE-NEXT:   } {alignment = 1 : i64, ast = #cir.var.decl.ast}
 // BEFORE-NEXT: }
 
@@ -41,29 +41,29 @@ static Init __ioinit2(false);
 // AFTER:      module {{.*}} attributes {{.*}}cir.global_ctors = [#cir.global_ctor<"__cxx_global_var_init", 65536>, #cir.global_ctor<"__cxx_global_var_init.1", 65536>]
 // AFTER-NEXT:   cir.global "private" external @__dso_handle : i8
 // AFTER-NEXT:   cir.func private @__cxa_atexit(!cir.ptr<!cir.func<!void (!cir.ptr<!void>)>>, !cir.ptr<!void>, !cir.ptr<i8>)
-// AFTER-NEXT:   cir.func private @_ZN4InitC1Eb(!cir.ptr<!ty_22Init22>, !cir.bool)
-// AFTER-NEXT:   cir.func private @_ZN4InitD1Ev(!cir.ptr<!ty_22Init22>)
-// AFTER-NEXT:   cir.global "private" internal dsolocal @_ZL8__ioinit =  #cir.zero : !ty_22Init22 {alignment = 1 : i64, ast = #cir.var.decl.ast}
+// AFTER-NEXT:   cir.func private @_ZN4InitC1Eb(!cir.ptr<!ty_Init>, !cir.bool)
+// AFTER-NEXT:   cir.func private @_ZN4InitD1Ev(!cir.ptr<!ty_Init>)
+// AFTER-NEXT:   cir.global "private" internal dsolocal @_ZL8__ioinit =  #cir.zero : !ty_Init {alignment = 1 : i64, ast = #cir.var.decl.ast}
 // AFTER-NEXT:   cir.func internal private @__cxx_global_var_init()
-// AFTER-NEXT:     %0 = cir.get_global @_ZL8__ioinit : !cir.ptr<!ty_22Init22>
+// AFTER-NEXT:     %0 = cir.get_global @_ZL8__ioinit : !cir.ptr<!ty_Init>
 // AFTER-NEXT:     %1 = cir.const #true
-// AFTER-NEXT:     cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr<!ty_22Init22>, !cir.bool) -> ()
-// AFTER-NEXT:     %2 = cir.get_global @_ZL8__ioinit : !cir.ptr<!ty_22Init22>
-// AFTER-NEXT:     %3 = cir.get_global @_ZN4InitD1Ev : !cir.ptr<!cir.func<!void (!cir.ptr<!ty_22Init22>)>>
-// AFTER-NEXT:     %4 = cir.cast(bitcast, %3 : !cir.ptr<!cir.func<!void (!cir.ptr<!ty_22Init22>)>>), !cir.ptr<!cir.func<!void (!cir.ptr<!void>)>>
-// AFTER-NEXT:     %5 = cir.cast(bitcast, %2 : !cir.ptr<!ty_22Init22>), !cir.ptr<!void>
+// AFTER-NEXT:     cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr<!ty_Init>, !cir.bool) -> ()
+// AFTER-NEXT:     %2 = cir.get_global @_ZL8__ioinit : !cir.ptr<!ty_Init>
+// AFTER-NEXT:     %3 = cir.get_global @_ZN4InitD1Ev : !cir.ptr<!cir.func<!void (!cir.ptr<!ty_Init>)>>
+// AFTER-NEXT:     %4 = cir.cast(bitcast, %3 : !cir.ptr<!cir.func<!void (!cir.ptr<!ty_Init>)>>), !cir.ptr<!cir.func<!void (!cir.ptr<!void>)>>
+// AFTER-NEXT:     %5 = cir.cast(bitcast, %2 : !cir.ptr<!ty_Init>), !cir.ptr<!void>
 // AFTER-NEXT:     %6 = cir.get_global @__dso_handle : !cir.ptr<i8>
 // AFTER-NEXT:     cir.call @__cxa_atexit(%4, %5, %6) : (!cir.ptr<!cir.func<!void (!cir.ptr<!void>)>>, !cir.ptr<!void>, !cir.ptr<i8>) -> ()
 // AFTER-NEXT:     cir.return
-// AFTER:        cir.global "private" internal dsolocal @_ZL9__ioinit2 =  #cir.zero : !ty_22Init22 {alignment = 1 : i64, ast = #cir.var.decl.ast}
+// AFTER:        cir.global "private" internal dsolocal @_ZL9__ioinit2 =  #cir.zero : !ty_Init {alignment = 1 : i64, ast = #cir.var.decl.ast}
 // AFTER-NEXT:   cir.func internal private @__cxx_global_var_init.1()
-// AFTER-NEXT:     %0 = cir.get_global @_ZL9__ioinit2 : !cir.ptr<!ty_22Init22>
+// AFTER-NEXT:     %0 = cir.get_global @_ZL9__ioinit2 : !cir.ptr<!ty_Init>
 // AFTER-NEXT:     %1 = cir.const #false
-// AFTER-NEXT:     cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr<!ty_22Init22>, !cir.bool) -> ()
-// AFTER-NEXT:     %2 = cir.get_global @_ZL9__ioinit2 : !cir.ptr<!ty_22Init22>
-// AFTER-NEXT:     %3 = cir.get_global @_ZN4InitD1Ev : !cir.ptr<!cir.func<!void (!cir.ptr<!ty_22Init22>)>>
-// AFTER-NEXT:     %4 = cir.cast(bitcast, %3 : !cir.ptr<!cir.func<!void (!cir.ptr<!ty_22Init22>)>>), !cir.ptr<!cir.func<!void (!cir.ptr<!void>)>>
-// AFTER-NEXT:     %5 = cir.cast(bitcast, %2 : !cir.ptr<!ty_22Init22>), !cir.ptr<!void>
+// AFTER-NEXT:     cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr<!ty_Init>, !cir.bool) -> ()
+// AFTER-NEXT:     %2 = cir.get_global @_ZL9__ioinit2 : !cir.ptr<!ty_Init>
+// AFTER-NEXT:     %3 = cir.get_global @_ZN4InitD1Ev : !cir.ptr<!cir.func<!void (!cir.ptr<!ty_Init>)>>
+// AFTER-NEXT:     %4 = cir.cast(bitcast, %3 : !cir.ptr<!cir.func<!void (!cir.ptr<!ty_Init>)>>), !cir.ptr<!cir.func<!void (!cir.ptr<!void>)>>
+// AFTER-NEXT:     %5 = cir.cast(bitcast, %2 : !cir.ptr<!ty_Init>), !cir.ptr<!void>
 // AFTER-NEXT:     %6 = cir.get_global @__dso_handle : !cir.ptr<i8>
 // AFTER-NEXT:     cir.call @__cxa_atexit(%4, %5, %6) : (!cir.ptr<!cir.func<!void (!cir.ptr<!void>)>>, !cir.ptr<!void>, !cir.ptr<i8>) -> ()
 // AFTER-NEXT:     cir.return
diff --git a/clang/test/CIR/CodeGen/stmt-expr.c b/clang/test/CIR/CodeGen/stmt-expr.c
index d3944cb72505..0e3daebb9d78 100644
--- a/clang/test/CIR/CodeGen/stmt-expr.c
+++ b/clang/test/CIR/CodeGen/stmt-expr.c
@@ -24,13 +24,13 @@ void test2() { ({int x = 3; x; }); }
 struct S { int x; };
 int test3() { return ({ struct S s = {1}; s; }).x; }
 // CHECK: @test3
-// CHECK: %[[#RETVAL:]] = cir.alloca !ty_22S22, !cir.ptr<!ty_22S22>
+// CHECK: %[[#RETVAL:]] = cir.alloca !ty_S, !cir.ptr<!ty_S>
 // CHECK: cir.scope {
-// CHECK:   %[[#VAR:]] = cir.alloca !ty_22S22, !cir.ptr<!ty_22S22>
+// CHECK:   %[[#VAR:]] = cir.alloca !ty_S, !cir.ptr<!ty_S>
 //          [...]
-// CHECK:   cir.copy %[[#VAR]] to %[[#RETVAL]] : !cir.ptr<!ty_22S22>
+// CHECK:   cir.copy %[[#VAR]] to %[[#RETVAL]] : !cir.ptr<!ty_S>
 // CHECK: }
-// CHECK: %[[#RETADDR:]] = cir.get_member %1[0] {name = "x"} : !cir.ptr<!ty_22S22> -> !cir.ptr<!s32i>
+// CHECK: %[[#RETADDR:]] = cir.get_member %1[0] {name = "x"} : !cir.ptr<!ty_S> -> !cir.ptr<!s32i>
 // CHECK: %{{.+}} = cir.load %[[#RETADDR]] : !cir.ptr<!s32i>, !s32i
 
 // Expression is wrapped in an expression attribute (just ensure it does not crash).
diff --git a/clang/test/CIR/CodeGen/stmt-expr.cpp b/clang/test/CIR/CodeGen/stmt-expr.cpp
index 9d6ba7466855..8432df4e15af 100644
--- a/clang/test/CIR/CodeGen/stmt-expr.cpp
+++ b/clang/test/CIR/CodeGen/stmt-expr.cpp
@@ -19,13 +19,13 @@ void test1() {
 }
 // CHECK: @_Z5test1v
 // CHECK: cir.scope {
-// CHECK:   %[[#RETVAL:]] = cir.alloca !ty_22A22, !cir.ptr<!ty_22A22>
+// CHECK:   %[[#RETVAL:]] = cir.alloca !ty_A, !cir.ptr<!ty_A>
 // CHECK:   cir.scope {
-// CHECK:     %[[#VAR:]] = cir.alloca !ty_22A22, !cir.ptr<!ty_22A22>, ["a", init] {alignment = 4 : i64}
-// CHECK:     cir.call @_ZN1AC1Ev(%[[#VAR]]) : (!cir.ptr<!ty_22A22>) -> ()
-// CHECK:     cir.call @_ZN1AC1ERS_(%[[#RETVAL]], %[[#VAR]]) : (!cir.ptr<!ty_22A22>, !cir.ptr<!ty_22A22>) -> ()
+// CHECK:     %[[#VAR:]] = cir.alloca !ty_A, !cir.ptr<!ty_A>, ["a", init] {alignment = 4 : i64}
+// CHECK:     cir.call @_ZN1AC1Ev(%[[#VAR]]) : (!cir.ptr<!ty_A>) -> ()
+// CHECK:     cir.call @_ZN1AC1ERS_(%[[#RETVAL]], %[[#VAR]]) : (!cir.ptr<!ty_A>, !cir.ptr<!ty_A>) -> ()
 //            TODO(cir): the local VAR should be destroyed here.
 // CHECK:   }
-// CHECK:   cir.call @_ZN1A3FooEv(%[[#RETVAL]]) : (!cir.ptr<!ty_22A22>) -> ()
+// CHECK:   cir.call @_ZN1A3FooEv(%[[#RETVAL]]) : (!cir.ptr<!ty_A>) -> ()
 //          TODO(cir): the temporary RETVAL should be destroyed here.
 // CHECK: }
diff --git a/clang/test/CIR/CodeGen/stmtexpr-init.c b/clang/test/CIR/CodeGen/stmtexpr-init.c
index f72ba432206f..b57562511fc9 100644
--- a/clang/test/CIR/CodeGen/stmtexpr-init.c
+++ b/clang/test/CIR/CodeGen/stmtexpr-init.c
@@ -3,8 +3,8 @@
 // RUN: %clang_cc1 -triple aarch64-none-linux-android21 -fclangir -emit-llvm %s -o %t.ll
 // RUN: FileCheck --check-prefix=LLVM --input-file=%t.ll %s
 
-// CIR: ![[sized_array:.*]] = !cir.struct<struct "sized_array" {!cir.int<s, 32>, !cir.array<!cir.int<s, 32> x 0>}
 // CIR: ![[annon_struct:.*]] = !cir.struct<struct  {!cir.int<s, 32>, !cir.array<!cir.int<s, 32> x 2>}>
+// CIR: ![[sized_array:.*]] = !cir.struct<struct "sized_array" {!cir.int<s, 32>, !cir.array<!cir.int<s, 32> x 0>}
 
 void escape(const void *);
 
diff --git a/clang/test/CIR/CodeGen/struct.c b/clang/test/CIR/CodeGen/struct.c
index 61e6fc5fd446..863f4e0ce8f1 100644
--- a/clang/test/CIR/CodeGen/struct.c
+++ b/clang/test/CIR/CodeGen/struct.c
@@ -22,29 +22,29 @@ void baz(void) {
   struct Foo f;
 }
 
-// CHECK-DAG: !ty_22Node22 = !cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node">>} #cir.record.decl.ast>
-// CHECK-DAG: !ty_22Bar22 = !cir.struct<struct "Bar" {!cir.int<s, 32>, !cir.int<s, 8>}>
-// CHECK-DAG: !ty_22Foo22 = !cir.struct<struct "Foo" {!cir.int<s, 32>, !cir.int<s, 8>, !cir.struct<struct "Bar" {!cir.int<s, 32>, !cir.int<s, 8>}>}>
+// CHECK-DAG: !ty_Node = !cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node">>} #cir.record.decl.ast>
+// CHECK-DAG: !ty_Bar = !cir.struct<struct "Bar" {!cir.int<s, 32>, !cir.int<s, 8>}>
+// CHECK-DAG: !ty_Foo = !cir.struct<struct "Foo" {!cir.int<s, 32>, !cir.int<s, 8>, !cir.struct<struct "Bar" {!cir.int<s, 32>, !cir.int<s, 8>}>}>
 //  CHECK-DAG: module {{.*}} {
      // CHECK:   cir.func @baz()
-// CHECK-NEXT:     %0 = cir.alloca !ty_22Bar22, !cir.ptr<!ty_22Bar22>, ["b"] {alignment = 4 : i64}
-// CHECK-NEXT:     %1 = cir.alloca !ty_22Foo22, !cir.ptr<!ty_22Foo22>, ["f"] {alignment = 4 : i64}
+// CHECK-NEXT:     %0 = cir.alloca !ty_Bar, !cir.ptr<!ty_Bar>, ["b"] {alignment = 4 : i64}
+// CHECK-NEXT:     %1 = cir.alloca !ty_Foo, !cir.ptr<!ty_Foo>, ["f"] {alignment = 4 : i64}
 // CHECK-NEXT:     cir.return
 // CHECK-NEXT:   }
 
 void shouldConstInitStructs(void) {
 // CHECK: cir.func @shouldConstInitStructs
   struct Foo f = {1, 2, {3, 4}};
-  // CHECK: %[[#V0:]] = cir.alloca !ty_22Foo22, !cir.ptr<!ty_22Foo22>, ["f"] {alignment = 4 : i64}
-  // CHECK: %[[#V1:]] = cir.const #cir.const_struct<{#cir.int<1> : !s32i, #cir.int<2> : !s8i, #cir.const_struct<{#cir.int<3> : !s32i, #cir.int<4> : !s8i}> : !ty_22Bar22}> : !ty_22Foo22
-  // CHECK: cir.store %[[#V1]], %[[#V0]] : !ty_22Foo22, !cir.ptr<!ty_22Foo22>
+  // CHECK: %[[#V0:]] = cir.alloca !ty_Foo, !cir.ptr<!ty_Foo>, ["f"] {alignment = 4 : i64}
+  // CHECK: %[[#V1:]] = cir.const #cir.const_struct<{#cir.int<1> : !s32i, #cir.int<2> : !s8i, #cir.const_struct<{#cir.int<3> : !s32i, #cir.int<4> : !s8i}> : !ty_Bar}> : !ty_Foo
+  // CHECK: cir.store %[[#V1]], %[[#V0]] : !ty_Foo, !cir.ptr<!ty_Foo>
 }
 
 // Should zero-initialize uninitialized global structs.
 struct S {
   int a,b;
 } s;
-// CHECK-DAG: cir.global external @s = #cir.zero : !ty_22S22
+// CHECK-DAG: cir.global external @s = #cir.zero : !ty_S
 
 // Should initialize basic global structs.
 struct S1 {
@@ -52,7 +52,7 @@ struct S1 {
   float f;
   int *p;
 } s1 = {1, .1, 0};
-// CHECK-DAG: cir.global external @s1 = #cir.const_struct<{#cir.int<1> : !s32i, #cir.fp<1.000000e-01> : !cir.float, #cir.ptr<null> : !cir.ptr<!s32i>}> : !ty_22S122
+// CHECK-DAG: cir.global external @s1 = #cir.const_struct<{#cir.int<1> : !s32i, #cir.fp<1.000000e-01> : !cir.float, #cir.ptr<null> : !cir.ptr<!s32i>}> : !ty_S1_
 
 // Should initialize global nested structs.
 struct S2 {
@@ -60,19 +60,19 @@ struct S2 {
     int a;
   } s2a;
 } s2 = {{1}};
-// CHECK-DAG: cir.global external @s2 = #cir.const_struct<{#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_22S2A22}> : !ty_22S222
+// CHECK-DAG: cir.global external @s2 = #cir.const_struct<{#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_S2A}> : !ty_S2_
 
 // Should initialize global arrays of structs.
 struct S3 {
   int a;
 } s3[3] = {{1}, {2}, {3}};
-// CHECK-DAG: cir.global external @s3 = #cir.const_array<[#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_22S322, #cir.const_struct<{#cir.int<2> : !s32i}> : !ty_22S322, #cir.const_struct<{#cir.int<3> : !s32i}> : !ty_22S322]> : !cir.array<!ty_22S322 x 3>
+// CHECK-DAG: cir.global external @s3 = #cir.const_array<[#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_S3_, #cir.const_struct<{#cir.int<2> : !s32i}> : !ty_S3_, #cir.const_struct<{#cir.int<3> : !s32i}> : !ty_S3_]> : !cir.array<!ty_S3_ x 3>
 
 void shouldCopyStructAsCallArg(struct S1 s) {
 // CHECK-DAG: cir.func @shouldCopyStructAsCallArg
   shouldCopyStructAsCallArg(s);
-  // CHECK-DAG: %[[#LV:]] = cir.load %{{.+}} : !cir.ptr<!ty_22S122>, !ty_22S122
-  // CHECK-DAG: cir.call @shouldCopyStructAsCallArg(%[[#LV]]) : (!ty_22S122) -> ()
+  // CHECK-DAG: %[[#LV:]] = cir.load %{{.+}} : !cir.ptr<!ty_S1_>, !ty_S1_
+  // CHECK-DAG: cir.call @shouldCopyStructAsCallArg(%[[#LV]]) : (!ty_S1_) -> ()
 }
 
 struct Bar shouldGenerateAndAccessStructArrays(void) {
@@ -81,12 +81,12 @@ struct Bar shouldGenerateAndAccessStructArrays(void) {
 }
 // CHECK-DAG: cir.func @shouldGenerateAndAccessStructArrays
 // CHECK-DAG: %[[#STRIDE:]] = cir.const #cir.int<0> : !s32i
-// CHECK-DAG: %[[#DARR:]] = cir.cast(array_to_ptrdecay, %{{.+}} : !cir.ptr<!cir.array<!ty_22Bar22 x 1>>), !cir.ptr<!ty_22Bar22>
-// CHECK-DAG: %[[#ELT:]] = cir.ptr_stride(%[[#DARR]] : !cir.ptr<!ty_22Bar22>, %[[#STRIDE]] : !s32i), !cir.ptr<!ty_22Bar22>
-// CHECK-DAG: cir.copy %[[#ELT]] to %{{.+}} : !cir.ptr<!ty_22Bar22>
+// CHECK-DAG: %[[#DARR:]] = cir.cast(array_to_ptrdecay, %{{.+}} : !cir.ptr<!cir.array<!ty_Bar x 1>>), !cir.ptr<!ty_Bar>
+// CHECK-DAG: %[[#ELT:]] = cir.ptr_stride(%[[#DARR]] : !cir.ptr<!ty_Bar>, %[[#STRIDE]] : !s32i), !cir.ptr<!ty_Bar>
+// CHECK-DAG: cir.copy %[[#ELT]] to %{{.+}} : !cir.ptr<!ty_Bar>
 
 // CHECK-DAG: cir.func @local_decl
-// CHECK-DAG: {{%.}} = cir.alloca !ty_22Local22, !cir.ptr<!ty_22Local22>, ["a"]
+// CHECK-DAG: {{%.}} = cir.alloca !ty_Local, !cir.ptr<!ty_Local>, ["a"]
 void local_decl(void) {
   struct Local {
     int i;
@@ -95,7 +95,7 @@ void local_decl(void) {
 }
 
 // CHECK-DAG: cir.func @useRecursiveType
-// CHECK-DAG: cir.get_member {{%.}}[0] {name = "next"} : !cir.ptr<!ty_22Node22> -> !cir.ptr<!cir.ptr<!ty_22Node22>>
+// CHECK-DAG: cir.get_member {{%.}}[0] {name = "next"} : !cir.ptr<!ty_Node> -> !cir.ptr<!cir.ptr<!ty_Node>>
 void useRecursiveType(NodeStru* a) {
   a->next = 0;
 }
diff --git a/clang/test/CIR/CodeGen/struct.cpp b/clang/test/CIR/CodeGen/struct.cpp
index d57fd7ae49c3..5b83a573e3b4 100644
--- a/clang/test/CIR/CodeGen/struct.cpp
+++ b/clang/test/CIR/CodeGen/struct.cpp
@@ -26,37 +26,37 @@ void baz() {
 struct incomplete;
 void yoyo(incomplete *i) {}
 
-//  CHECK-DAG: !ty_22incomplete22 = !cir.struct<struct "incomplete" incomplete
-//  CHECK-DAG: !ty_22Bar22 = !cir.struct<struct "Bar" {!cir.int<s, 32>, !cir.int<s, 8>}>
-
-//  CHECK-DAG: !ty_22Foo22 = !cir.struct<struct "Foo" {!cir.int<s, 32>, !cir.int<s, 8>, !cir.struct<struct "Bar" {!cir.int<s, 32>, !cir.int<s, 8>}>}>
-//  CHECK-DAG: !ty_22Mandalore22 = !cir.struct<struct "Mandalore" {!cir.int<u, 32>, !cir.ptr<!cir.void>, !cir.int<s, 32>} #cir.record.decl.ast>
-//  CHECK-DAG: !ty_22Adv22 = !cir.struct<class "Adv" {!cir.struct<struct "Mandalore" {!cir.int<u, 32>, !cir.ptr<!cir.void>, !cir.int<s, 32>} #cir.record.decl.ast>}>
-//  CHECK-DAG: !ty_22Entry22 = !cir.struct<struct "Entry" {!cir.ptr<!cir.func<!cir.int<u, 32> (!cir.int<s, 32>, !cir.ptr<!cir.int<s, 8>>, !cir.ptr<!cir.void>)>>}>
-
-//      CHECK: cir.func linkonce_odr @_ZN3Bar6methodEv(%arg0: !cir.ptr<!ty_22Bar22>
-// CHECK-NEXT:   %0 = cir.alloca !cir.ptr<!ty_22Bar22>, !cir.ptr<!cir.ptr<!ty_22Bar22>>, ["this", init] {alignment = 8 : i64}
-// CHECK-NEXT:   cir.store %arg0, %0 : !cir.ptr<!ty_22Bar22>, !cir.ptr<!cir.ptr<!ty_22Bar22>>
-// CHECK-NEXT:   %1 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22Bar22>>, !cir.ptr<!ty_22Bar22>
+//  CHECK-DAG: !ty_incomplete = !cir.struct<struct "incomplete" incomplete
+//  CHECK-DAG: !ty_Bar = !cir.struct<struct "Bar" {!cir.int<s, 32>, !cir.int<s, 8>}>
+
+//  CHECK-DAG: !ty_Foo = !cir.struct<struct "Foo" {!cir.int<s, 32>, !cir.int<s, 8>, !cir.struct<struct "Bar" {!cir.int<s, 32>, !cir.int<s, 8>}>}>
+//  CHECK-DAG: !ty_Mandalore = !cir.struct<struct "Mandalore" {!cir.int<u, 32>, !cir.ptr<!cir.void>, !cir.int<s, 32>} #cir.record.decl.ast>
+//  CHECK-DAG: !ty_Adv = !cir.struct<class "Adv" {!cir.struct<struct "Mandalore" {!cir.int<u, 32>, !cir.ptr<!cir.void>, !cir.int<s, 32>} #cir.record.decl.ast>}>
+//  CHECK-DAG: !ty_Entry = !cir.struct<struct "Entry" {!cir.ptr<!cir.func<!cir.int<u, 32> (!cir.int<s, 32>, !cir.ptr<!cir.int<s, 8>>, !cir.ptr<!cir.void>)>>}>
+
+//      CHECK: cir.func linkonce_odr @_ZN3Bar6methodEv(%arg0: !cir.ptr<!ty_Bar>
+// CHECK-NEXT:   %0 = cir.alloca !cir.ptr<!ty_Bar>, !cir.ptr<!cir.ptr<!ty_Bar>>, ["this", init] {alignment = 8 : i64}
+// CHECK-NEXT:   cir.store %arg0, %0 : !cir.ptr<!ty_Bar>, !cir.ptr<!cir.ptr<!ty_Bar>>
+// CHECK-NEXT:   %1 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_Bar>>, !cir.ptr<!ty_Bar>
 // CHECK-NEXT:   cir.return
 // CHECK-NEXT: }
 
-//      CHECK: cir.func linkonce_odr @_ZN3Bar7method2Ei(%arg0: !cir.ptr<!ty_22Bar22> {{.*}}, %arg1: !s32i
-// CHECK-NEXT:   %0 = cir.alloca !cir.ptr<!ty_22Bar22>, !cir.ptr<!cir.ptr<!ty_22Bar22>>, ["this", init] {alignment = 8 : i64}
+//      CHECK: cir.func linkonce_odr @_ZN3Bar7method2Ei(%arg0: !cir.ptr<!ty_Bar> {{.*}}, %arg1: !s32i
+// CHECK-NEXT:   %0 = cir.alloca !cir.ptr<!ty_Bar>, !cir.ptr<!cir.ptr<!ty_Bar>>, ["this", init] {alignment = 8 : i64}
 // CHECK-NEXT:   %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
-// CHECK-NEXT:   cir.store %arg0, %0 : !cir.ptr<!ty_22Bar22>, !cir.ptr<!cir.ptr<!ty_22Bar22>>
+// CHECK-NEXT:   cir.store %arg0, %0 : !cir.ptr<!ty_Bar>, !cir.ptr<!cir.ptr<!ty_Bar>>
 // CHECK-NEXT:   cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
-// CHECK-NEXT:   %2 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22Bar22>>, !cir.ptr<!ty_22Bar22>
+// CHECK-NEXT:   %2 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_Bar>>, !cir.ptr<!ty_Bar>
 // CHECK-NEXT:   cir.return
 // CHECK-NEXT: }
 
-//      CHECK: cir.func linkonce_odr @_ZN3Bar7method3Ei(%arg0: !cir.ptr<!ty_22Bar22> {{.*}}, %arg1: !s32i
-// CHECK-NEXT:   %0 = cir.alloca !cir.ptr<!ty_22Bar22>, !cir.ptr<!cir.ptr<!ty_22Bar22>>, ["this", init] {alignment = 8 : i64}
+//      CHECK: cir.func linkonce_odr @_ZN3Bar7method3Ei(%arg0: !cir.ptr<!ty_Bar> {{.*}}, %arg1: !s32i
+// CHECK-NEXT:   %0 = cir.alloca !cir.ptr<!ty_Bar>, !cir.ptr<!cir.ptr<!ty_Bar>>, ["this", init] {alignment = 8 : i64}
 // CHECK-NEXT:   %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
 // CHECK-NEXT:   %2 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
-// CHECK-NEXT:   cir.store %arg0, %0 : !cir.ptr<!ty_22Bar22>, !cir.ptr<!cir.ptr<!ty_22Bar22>>
+// CHECK-NEXT:   cir.store %arg0, %0 : !cir.ptr<!ty_Bar>, !cir.ptr<!cir.ptr<!ty_Bar>>
 // CHECK-NEXT:   cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
-// CHECK-NEXT:   %3 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22Bar22>>, !cir.ptr<!ty_22Bar22>
+// CHECK-NEXT:   %3 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_Bar>>, !cir.ptr<!ty_Bar>
 // CHECK-NEXT:   %4 = cir.load %1 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:   cir.store %4, %2 : !s32i, !cir.ptr<!s32i>
 // CHECK-NEXT:   %5 = cir.load %2 : !cir.ptr<!s32i>, !s32i
@@ -64,14 +64,14 @@ void yoyo(incomplete *i) {}
 // CHECK-NEXT: }
 
 //      CHECK: cir.func @_Z3bazv()
-// CHECK-NEXT:   %0 = cir.alloca !ty_22Bar22, !cir.ptr<!ty_22Bar22>, ["b"] {alignment = 4 : i64}
+// CHECK-NEXT:   %0 = cir.alloca !ty_Bar, !cir.ptr<!ty_Bar>, ["b"] {alignment = 4 : i64}
 // CHECK-NEXT:   %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["result", init] {alignment = 4 : i64}
-// CHECK-NEXT:   %2 = cir.alloca !ty_22Foo22, !cir.ptr<!ty_22Foo22>, ["f"] {alignment = 4 : i64}
-// CHECK-NEXT:   cir.call @_ZN3Bar6methodEv(%0) : (!cir.ptr<!ty_22Bar22>) -> ()
+// CHECK-NEXT:   %2 = cir.alloca !ty_Foo, !cir.ptr<!ty_Foo>, ["f"] {alignment = 4 : i64}
+// CHECK-NEXT:   cir.call @_ZN3Bar6methodEv(%0) : (!cir.ptr<!ty_Bar>) -> ()
 // CHECK-NEXT:   %3 = cir.const #cir.int<4> : !s32i
-// CHECK-NEXT:   cir.call @_ZN3Bar7method2Ei(%0, %3) : (!cir.ptr<!ty_22Bar22>, !s32i) -> ()
+// CHECK-NEXT:   cir.call @_ZN3Bar7method2Ei(%0, %3) : (!cir.ptr<!ty_Bar>, !s32i) -> ()
 // CHECK-NEXT:   %4 = cir.const #cir.int<4> : !s32i
-// CHECK-NEXT:   %5 = cir.call @_ZN3Bar7method3Ei(%0, %4) : (!cir.ptr<!ty_22Bar22>, !s32i) -> !s32i
+// CHECK-NEXT:   %5 = cir.call @_ZN3Bar7method3Ei(%0, %4) : (!cir.ptr<!ty_Bar>, !s32i) -> !s32i
 // CHECK-NEXT:   cir.store %5, %1 : !s32i, !cir.ptr<!s32i>
 // CHECK-NEXT:   cir.return
 // CHECK-NEXT: }
@@ -94,18 +94,18 @@ class Adv {
 
 void m() { Adv C; }
 
-// CHECK: cir.func linkonce_odr @_ZN3AdvC2Ev(%arg0: !cir.ptr<!ty_22Adv22>
-// CHECK:     %0 = cir.alloca !cir.ptr<!ty_22Adv22>, !cir.ptr<!cir.ptr<!ty_22Adv22>>, ["this", init] {alignment = 8 : i64}
-// CHECK:     cir.store %arg0, %0 : !cir.ptr<!ty_22Adv22>, !cir.ptr<!cir.ptr<!ty_22Adv22>>
-// CHECK:     %1 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22Adv22>>, !cir.ptr<!ty_22Adv22>
-// CHECK:     %2 = cir.get_member %1[0] {name = "x"} : !cir.ptr<!ty_22Adv22> -> !cir.ptr<!ty_22Mandalore22>
-// CHECK:     %3 = cir.get_member %2[0] {name = "w"} : !cir.ptr<!ty_22Mandalore22> -> !cir.ptr<!u32i>
+// CHECK: cir.func linkonce_odr @_ZN3AdvC2Ev(%arg0: !cir.ptr<!ty_Adv>
+// CHECK:     %0 = cir.alloca !cir.ptr<!ty_Adv>, !cir.ptr<!cir.ptr<!ty_Adv>>, ["this", init] {alignment = 8 : i64}
+// CHECK:     cir.store %arg0, %0 : !cir.ptr<!ty_Adv>, !cir.ptr<!cir.ptr<!ty_Adv>>
+// CHECK:     %1 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_Adv>>, !cir.ptr<!ty_Adv>
+// CHECK:     %2 = cir.get_member %1[0] {name = "x"} : !cir.ptr<!ty_Adv> -> !cir.ptr<!ty_Mandalore>
+// CHECK:     %3 = cir.get_member %2[0] {name = "w"} : !cir.ptr<!ty_Mandalore> -> !cir.ptr<!u32i>
 // CHECK:     %4 = cir.const #cir.int<1000024001> : !u32i
 // CHECK:     cir.store %4, %3 : !u32i, !cir.ptr<!u32i>
-// CHECK:     %5 = cir.get_member %2[1] {name = "n"} : !cir.ptr<!ty_22Mandalore22> -> !cir.ptr<!cir.ptr<!void>>
+// CHECK:     %5 = cir.get_member %2[1] {name = "n"} : !cir.ptr<!ty_Mandalore> -> !cir.ptr<!cir.ptr<!void>>
 // CHECK:     %6 = cir.const #cir.ptr<null> : !cir.ptr<!void>
 // CHECK:     cir.store %6, %5 : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
-// CHECK:     %7 = cir.get_member %2[2] {name = "d"} : !cir.ptr<!ty_22Mandalore22> -> !cir.ptr<!s32i>
+// CHECK:     %7 = cir.get_member %2[2] {name = "d"} : !cir.ptr<!ty_Mandalore> -> !cir.ptr<!s32i>
 // CHECK:     %8 = cir.const #cir.int<0> : !s32i
 // CHECK:     cir.store %8, %7 : !s32i, !cir.ptr<!s32i>
 // CHECK:     cir.return
@@ -117,19 +117,19 @@ struct A {
 
 // Should globally const-initialize struct members.
 struct A simpleConstInit = {1};
-// CHECK: cir.global external @simpleConstInit = #cir.const_struct<{#cir.int<1> : !s32i}> : !ty_22A22
+// CHECK: cir.global external @simpleConstInit = #cir.const_struct<{#cir.int<1> : !s32i}> : !ty_A
 
 // Should globally const-initialize arrays with struct members.
 struct A arrConstInit[1] = {{1}};
-// CHECK: cir.global external @arrConstInit = #cir.const_array<[#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_22A22]> : !cir.array<!ty_22A22 x 1>
+// CHECK: cir.global external @arrConstInit = #cir.const_array<[#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_A]> : !cir.array<!ty_A x 1>
 
 // Should locally copy struct members.
 void shouldLocallyCopyStructAssignments(void) {
   struct A a = { 3 };
-  // CHECK: %[[#SA:]] = cir.alloca !ty_22A22, !cir.ptr<!ty_22A22>, ["a"] {alignment = 4 : i64}
+  // CHECK: %[[#SA:]] = cir.alloca !ty_A, !cir.ptr<!ty_A>, ["a"] {alignment = 4 : i64}
   struct A b = a;
-  // CHECK: %[[#SB:]] = cir.alloca !ty_22A22, !cir.ptr<!ty_22A22>, ["b", init] {alignment = 4 : i64}
-  // cir.copy %[[#SA]] to %[[SB]] : !cir.ptr<!ty_22A22>
+  // CHECK: %[[#SB:]] = cir.alloca !ty_A, !cir.ptr<!ty_A>, ["b", init] {alignment = 4 : i64}
+  // cir.copy %[[#SA]] to %[[SB]] : !cir.ptr<!ty_A>
 }
 
 A get_default() { return A{2}; }
@@ -141,12 +141,12 @@ struct S {
 void h() { S s; }
 
 // CHECK: cir.func @_Z1hv()
-// CHECK:   %0 = cir.alloca !ty_22S22, !cir.ptr<!ty_22S22>, ["s", init] {alignment = 1 : i64}
-// CHECK:   %1 = cir.alloca !ty_22A22, !cir.ptr<!ty_22A22>, ["agg.tmp0"] {alignment = 4 : i64}
-// CHECK:   %2 = cir.call @_Z11get_defaultv() : () -> !ty_22A22
-// CHECK:   cir.store %2, %1 : !ty_22A22, !cir.ptr<!ty_22A22>
-// CHECK:   %3 = cir.load %1 : !cir.ptr<!ty_22A22>, !ty_22A22
-// CHECK:   cir.call @_ZN1SC1E1A(%0, %3) : (!cir.ptr<!ty_22S22>, !ty_22A22) -> ()
+// CHECK:   %0 = cir.alloca !ty_S, !cir.ptr<!ty_S>, ["s", init] {alignment = 1 : i64}
+// CHECK:   %1 = cir.alloca !ty_A, !cir.ptr<!ty_A>, ["agg.tmp0"] {alignment = 4 : i64}
+// CHECK:   %2 = cir.call @_Z11get_defaultv() : () -> !ty_A
+// CHECK:   cir.store %2, %1 : !ty_A, !cir.ptr<!ty_A>
+// CHECK:   %3 = cir.load %1 : !cir.ptr<!ty_A>, !ty_A
+// CHECK:   cir.call @_ZN1SC1E1A(%0, %3) : (!cir.ptr<!ty_S>, !ty_A) -> ()
 // CHECK:   cir.return
 // CHECK: }
 
@@ -162,6 +162,6 @@ struct Entry {
 
 void ppp() { Entry x; }
 
-// CHECK: cir.func linkonce_odr @_ZN5EntryC2Ev(%arg0: !cir.ptr<!ty_22Entry22>
+// CHECK: cir.func linkonce_odr @_ZN5EntryC2Ev(%arg0: !cir.ptr<!ty_Entry>
 
-// CHECK: cir.get_member %1[0] {name = "procAddr"} : !cir.ptr<!ty_22Entry22> -> !cir.ptr<!cir.ptr<!cir.func<!u32i (!s32i, !cir.ptr<!s8i>, !cir.ptr<!void>)>>>
+// CHECK: cir.get_member %1[0] {name = "procAddr"} : !cir.ptr<!ty_Entry> -> !cir.ptr<!cir.ptr<!cir.func<!u32i (!s32i, !cir.ptr<!s8i>, !cir.ptr<!void>)>>>
diff --git a/clang/test/CIR/CodeGen/structural-binding.cpp b/clang/test/CIR/CodeGen/structural-binding.cpp
index c7250d39a1e2..c37788b9d678 100644
--- a/clang/test/CIR/CodeGen/structural-binding.cpp
+++ b/clang/test/CIR/CodeGen/structural-binding.cpp
@@ -49,22 +49,22 @@ void f(A &a) {
 
   auto &[x, y, z] = a;
   (x, y, z);
-  // CIR: %[[a:.*]] = cir.load %1 : !cir.ptr<!cir.ptr<!ty_22A22>>, !cir.ptr<!ty_22A22>
-  // CIR: {{.*}} = cir.get_member %[[a]][0] {name = "a"} : !cir.ptr<!ty_22A22> -> !cir.ptr<!ty_22B22>
-  // CIR: %[[a:.*]] = cir.load %1 : !cir.ptr<!cir.ptr<!ty_22A22>>, !cir.ptr<!ty_22A22>
-  // CIR: {{.*}} = cir.get_member %[[a]][1] {name = "b"} : !cir.ptr<!ty_22A22> -> !cir.ptr<!s32i>
-  // CIR: %[[a:.*]] = cir.load %1 : !cir.ptr<!cir.ptr<!ty_22A22>>, !cir.ptr<!ty_22A22>
-  // CIR: {{.*}} = cir.get_member %[[a]][2] {name = "c"} : !cir.ptr<!ty_22A22> -> !cir.ptr<!s8i>
+  // CIR: %[[a:.*]] = cir.load %1 : !cir.ptr<!cir.ptr<!ty_A>>, !cir.ptr<!ty_A>
+  // CIR: {{.*}} = cir.get_member %[[a]][0] {name = "a"} : !cir.ptr<!ty_A> -> !cir.ptr<!ty_B>
+  // CIR: %[[a:.*]] = cir.load %1 : !cir.ptr<!cir.ptr<!ty_A>>, !cir.ptr<!ty_A>
+  // CIR: {{.*}} = cir.get_member %[[a]][1] {name = "b"} : !cir.ptr<!ty_A> -> !cir.ptr<!s32i>
+  // CIR: %[[a:.*]] = cir.load %1 : !cir.ptr<!cir.ptr<!ty_A>>, !cir.ptr<!ty_A>
+  // CIR: {{.*}} = cir.get_member %[[a]][2] {name = "c"} : !cir.ptr<!ty_A> -> !cir.ptr<!s8i>
   // LLVM: {{.*}} = getelementptr %struct.A, ptr {{.*}}, i32 0, i32 0
   // LLVM: {{.*}} = getelementptr %struct.A, ptr {{.*}}, i32 0, i32 1
   // LLVM: {{.*}} = getelementptr %struct.A, ptr {{.*}}, i32 0, i32 2
 
   auto [x2, y2, z2] = a;
   (x2, y2, z2);
-  // CIR: cir.call @_ZN1AC1ERKS_(%2, {{.*}}) : (!cir.ptr<!ty_22A22>, !cir.ptr<!ty_22A22>) -> ()
-  // CIR: {{.*}} = cir.get_member %2[0] {name = "a"} : !cir.ptr<!ty_22A22> -> !cir.ptr<!ty_22B22>
-  // CIR: {{.*}} = cir.get_member %2[1] {name = "b"} : !cir.ptr<!ty_22A22> -> !cir.ptr<!s32i>
-  // CIR: {{.*}} = cir.get_member %2[2] {name = "c"} : !cir.ptr<!ty_22A22> -> !cir.ptr<!s8i>
+  // CIR: cir.call @_ZN1AC1ERKS_(%2, {{.*}}) : (!cir.ptr<!ty_A>, !cir.ptr<!ty_A>) -> ()
+  // CIR: {{.*}} = cir.get_member %2[0] {name = "a"} : !cir.ptr<!ty_A> -> !cir.ptr<!ty_B>
+  // CIR: {{.*}} = cir.get_member %2[1] {name = "b"} : !cir.ptr<!ty_A> -> !cir.ptr<!s32i>
+  // CIR: {{.*}} = cir.get_member %2[2] {name = "c"} : !cir.ptr<!ty_A> -> !cir.ptr<!s8i>
 
   // for the rest, just expect the codegen does't crash
   auto &&[x3, y3, z3] = a;
@@ -84,10 +84,10 @@ void g(C &c) {
 
   auto [x8, y8] = c;
   (x8, y8);
-  // CIR: cir.call @_ZN1CC1ERKS_(%[[c:.*]], %7) : (!cir.ptr<!ty_22C22>, !cir.ptr<!ty_22C22>) -> ()
-  // CIR: %[[x8:.*]] = cir.call @_Z3getILj0EERKiRK1C(%[[c]]) : (!cir.ptr<!ty_22C22>) -> !cir.ptr<!s32i>
+  // CIR: cir.call @_ZN1CC1ERKS_(%[[c:.*]], %7) : (!cir.ptr<!ty_C>, !cir.ptr<!ty_C>) -> ()
+  // CIR: %[[x8:.*]] = cir.call @_Z3getILj0EERKiRK1C(%[[c]]) : (!cir.ptr<!ty_C>) -> !cir.ptr<!s32i>
   // CIR: cir.store %[[x8]], %[[x8p:.*]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
-  // CIR: %[[x9:.*]] = cir.call @_Z3getILj1EERKiRK1C(%[[c]]) : (!cir.ptr<!ty_22C22>) -> !cir.ptr<!s32i>
+  // CIR: %[[x9:.*]] = cir.call @_Z3getILj1EERKiRK1C(%[[c]]) : (!cir.ptr<!ty_C>) -> !cir.ptr<!s32i>
   // CIR: cir.store %[[x9]], %[[x9p:.*]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
   // CIR: {{.*}} = cir.load %[[x8p]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
   // CIR: {{.*}} = cir.load %[[x9p]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -97,12 +97,12 @@ void g(C &c) {
 
   auto &[x9, y9] = c;
   (x9, y9);
-  // CIR: cir.store %12, %[[cp:.*]] : !cir.ptr<!ty_22C22>, !cir.ptr<!cir.ptr<!ty_22C22>>
-  // CIR: %[[c:.*]] = cir.load %[[cp]] : !cir.ptr<!cir.ptr<!ty_22C22>>, !cir.ptr<!ty_22C22>
-  // CIR: %[[x8:.*]] = cir.call @_Z3getILj0EERKiRK1C(%[[c]]) : (!cir.ptr<!ty_22C22>) -> !cir.ptr<!s32i>
+  // CIR: cir.store %12, %[[cp:.*]] : !cir.ptr<!ty_C>, !cir.ptr<!cir.ptr<!ty_C>>
+  // CIR: %[[c:.*]] = cir.load %[[cp]] : !cir.ptr<!cir.ptr<!ty_C>>, !cir.ptr<!ty_C>
+  // CIR: %[[x8:.*]] = cir.call @_Z3getILj0EERKiRK1C(%[[c]]) : (!cir.ptr<!ty_C>) -> !cir.ptr<!s32i>
   // CIR: cir.store %[[x8]], %[[x8p:.*]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
-  // CIR: %[[c:.*]] = cir.load %[[cp]] : !cir.ptr<!cir.ptr<!ty_22C22>>, !cir.ptr<!ty_22C22>
-  // CIR: %[[x9:.*]] = cir.call @_Z3getILj1EERKiRK1C(%[[c]]) : (!cir.ptr<!ty_22C22>) -> !cir.ptr<!s32i>
+  // CIR: %[[c:.*]] = cir.load %[[cp]] : !cir.ptr<!cir.ptr<!ty_C>>, !cir.ptr<!ty_C>
+  // CIR: %[[x9:.*]] = cir.call @_Z3getILj1EERKiRK1C(%[[c]]) : (!cir.ptr<!ty_C>) -> !cir.ptr<!s32i>
   // CIR: cir.store %[[x9]], %[[x9p:.*]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
   // CIR: {{.*}} = cir.load %[[x8p]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
   // CIR: {{.*}} = cir.load %[[x9p]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i> 
diff --git a/clang/test/CIR/CodeGen/three-way-comparison.cpp b/clang/test/CIR/CodeGen/three-way-comparison.cpp
index 0d2f0dcab7ca..3a6f738c8fcc 100644
--- a/clang/test/CIR/CodeGen/three-way-comparison.cpp
+++ b/clang/test/CIR/CodeGen/three-way-comparison.cpp
@@ -7,8 +7,8 @@
 
 // BEFORE: #cmp3way_info_partial_ltn1eq0gt1unn127_ = #cir.cmp3way_info<partial, lt = -1, eq = 0, gt = 1, unordered = -127>
 // BEFORE: #cmp3way_info_strong_ltn1eq0gt1_ = #cir.cmp3way_info<strong, lt = -1, eq = 0, gt = 1>
-// BEFORE: !ty_22std3A3A__13A3Apartial_ordering22 = !cir.struct<class "std::__1::partial_ordering" {!cir.int<s, 8>}
-// BEFORE: !ty_22std3A3A__13A3Astrong_ordering22 = !cir.struct<class "std::__1::strong_ordering" {!cir.int<s, 8>}
+// BEFORE: !ty_std3A3A__13A3Apartial_ordering = !cir.struct<class "std::__1::partial_ordering" {!cir.int<s, 8>}
+// BEFORE: !ty_std3A3A__13A3Astrong_ordering = !cir.struct<class "std::__1::strong_ordering" {!cir.int<s, 8>}
 
 auto three_way_strong(int x, int y) {
   return x <=> y;
diff --git a/clang/test/CIR/CodeGen/typedef.c b/clang/test/CIR/CodeGen/typedef.c
index ea841c238b6f..2f34ff824e1c 100644
--- a/clang/test/CIR/CodeGen/typedef.c
+++ b/clang/test/CIR/CodeGen/typedef.c
@@ -6,5 +6,5 @@ void local_typedef() {
 }
 
 //CHECK:  cir.func no_proto @local_typedef()
-//CHECK:    {{.*}} = cir.alloca !ty_22Struct22, !cir.ptr<!ty_22Struct22>, ["s"] {alignment = 4 : i64}
+//CHECK:    {{.*}} = cir.alloca !ty_Struct, !cir.ptr<!ty_Struct>, ["s"] {alignment = 4 : i64}
 //CHECK:    cir.return
diff --git a/clang/test/CIR/CodeGen/union-init.c b/clang/test/CIR/CodeGen/union-init.c
index 963b7f82c936..d2efc5305077 100644
--- a/clang/test/CIR/CodeGen/union-init.c
+++ b/clang/test/CIR/CodeGen/union-init.c
@@ -20,13 +20,13 @@ void foo(int x) {
 
 // CHECK-LABEL:   cir.func @foo(
 // CHECK:  %[[VAL_1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
-// CHECK:  %[[VAL_2:.*]] = cir.alloca !ty_22A22, !cir.ptr<!ty_22A22>, ["a", init] {alignment = 4 : i64}
+// CHECK:  %[[VAL_2:.*]] = cir.alloca !ty_A, !cir.ptr<!ty_A>, ["a", init] {alignment = 4 : i64}
 // CHECK:  cir.store {{.*}}, %[[VAL_1]] : !s32i, !cir.ptr<!s32i>
-// CHECK:  %[[VAL_3:.*]] = cir.get_member %[[VAL_2]][1] {name = ""} : !cir.ptr<!ty_22A22> -> !cir.ptr<!ty_22anon2E122>
-// CHECK:  %[[VAL_4:.*]] = cir.cast(bitcast, %[[VAL_3]] : !cir.ptr<!ty_22anon2E122>), !cir.ptr<!u32i>
+// CHECK:  %[[VAL_3:.*]] = cir.get_member %[[VAL_2]][1] {name = ""} : !cir.ptr<!ty_A> -> !cir.ptr<!ty_anon2E1_>
+// CHECK:  %[[VAL_4:.*]] = cir.cast(bitcast, %[[VAL_3]] : !cir.ptr<!ty_anon2E1_>), !cir.ptr<!u32i>
 // CHECK:  %[[VAL_5:.*]] = cir.load %[[VAL_1]] : !cir.ptr<!s32i>, !s32i
 // CHECK:  %[[VAL_6:.*]] = cir.set_bitfield(#[[bfi_x]], %[[VAL_4]] : !cir.ptr<!u32i>, %[[VAL_5]] : !s32i) -> !s32i
-// CHECK:  %[[VAL_7:.*]] = cir.cast(bitcast, %[[VAL_3]] : !cir.ptr<!ty_22anon2E122>), !cir.ptr<!u32i>
+// CHECK:  %[[VAL_7:.*]] = cir.cast(bitcast, %[[VAL_3]] : !cir.ptr<!ty_anon2E1_>), !cir.ptr<!u32i>
 // CHECK:  %[[VAL_8:.*]] = cir.const #cir.int<0> : !s32i
 // CHECK:  %[[VAL_9:.*]] = cir.set_bitfield(#[[bfi_y]], %[[VAL_7]] : !cir.ptr<!u32i>, %[[VAL_8]] : !s32i) -> !s32i
 // CHECK:  cir.return
diff --git a/clang/test/CIR/CodeGen/union.cpp b/clang/test/CIR/CodeGen/union.cpp
index 8d32cf34eae5..ce32847da4f0 100644
--- a/clang/test/CIR/CodeGen/union.cpp
+++ b/clang/test/CIR/CodeGen/union.cpp
@@ -6,15 +6,15 @@ typedef union { yolo y; struct { int lifecnt; }; } yolm;
 typedef union { yolo y; struct { int *lifecnt; int genpad; }; } yolm2;
 typedef union { yolo y; struct { bool life; int genpad; }; } yolm3;
 
-// CHECK-DAG: !ty_22U23A3ADummy22 = !cir.struct<struct "U2::Dummy" {!cir.int<s, 16>, !cir.float} #cir.record.decl.ast>
-// CHECK-DAG: !ty_22anon2E522 = !cir.struct<struct "anon.5" {!cir.bool, !cir.int<s, 32>} #cir.record.decl.ast>
-// CHECK-DAG: !ty_22anon2E122 = !cir.struct<struct "anon.1" {!cir.int<s, 32>} #cir.record.decl.ast>
-// CHECK-DAG: !ty_22yolo22 = !cir.struct<struct "yolo" {!cir.int<s, 32>} #cir.record.decl.ast>
-// CHECK-DAG: !ty_22anon2E322 = !cir.struct<struct "anon.3" {!cir.ptr<!cir.int<s, 32>>, !cir.int<s, 32>} #cir.record.decl.ast>
+// CHECK-DAG: !ty_U23A3ADummy = !cir.struct<struct "U2::Dummy" {!cir.int<s, 16>, !cir.float} #cir.record.decl.ast>
+// CHECK-DAG: !ty_anon2E5_ = !cir.struct<struct "anon.5" {!cir.bool, !cir.int<s, 32>} #cir.record.decl.ast>
+// CHECK-DAG: !ty_anon2E1_ = !cir.struct<struct "anon.1" {!cir.int<s, 32>} #cir.record.decl.ast>
+// CHECK-DAG: !ty_yolo = !cir.struct<struct "yolo" {!cir.int<s, 32>} #cir.record.decl.ast>
+// CHECK-DAG: !ty_anon2E3_ = !cir.struct<struct "anon.3" {!cir.ptr<!cir.int<s, 32>>, !cir.int<s, 32>} #cir.record.decl.ast>
 
-// CHECK-DAG: !ty_22yolm22 = !cir.struct<union "yolm" {!cir.struct<struct "yolo" {!cir.int<s, 32>} #cir.record.decl.ast>, !cir.struct<struct "anon.1" {!cir.int<s, 32>} #cir.record.decl.ast>}>
-// CHECK-DAG: !ty_22yolm322 = !cir.struct<union "yolm3" {!cir.struct<struct "yolo" {!cir.int<s, 32>} #cir.record.decl.ast>, !cir.struct<struct "anon.5" {!cir.bool, !cir.int<s, 32>} #cir.record.decl.ast>}>
-// CHECK-DAG: !ty_22yolm222 = !cir.struct<union "yolm2" {!cir.struct<struct "yolo" {!cir.int<s, 32>} #cir.record.decl.ast>, !cir.struct<struct "anon.3" {!cir.ptr<!cir.int<s, 32>>, !cir.int<s, 32>} #cir.record.decl.ast>}>
+// CHECK-DAG: !ty_yolm = !cir.struct<union "yolm" {!cir.struct<struct "yolo" {!cir.int<s, 32>} #cir.record.decl.ast>, !cir.struct<struct "anon.1" {!cir.int<s, 32>} #cir.record.decl.ast>}>
+// CHECK-DAG: !ty_yolm3_ = !cir.struct<union "yolm3" {!cir.struct<struct "yolo" {!cir.int<s, 32>} #cir.record.decl.ast>, !cir.struct<struct "anon.5" {!cir.bool, !cir.int<s, 32>} #cir.record.decl.ast>}>
+// CHECK-DAG: !ty_yolm2_ = !cir.struct<union "yolm2" {!cir.struct<struct "yolo" {!cir.int<s, 32>} #cir.record.decl.ast>, !cir.struct<struct "anon.3" {!cir.ptr<!cir.int<s, 32>>, !cir.int<s, 32>} #cir.record.decl.ast>}>
 
 // Should generate a union type with all members preserved.
 union U {
@@ -24,7 +24,7 @@ union U {
   float f;
   double d;
 };
-// CHECK-DAG: !ty_22U22 = !cir.struct<union "U" {!cir.bool, !cir.int<s, 16>, !cir.int<s, 32>, !cir.float, !cir.double}>
+// CHECK-DAG: !ty_U = !cir.struct<union "U" {!cir.bool, !cir.int<s, 16>, !cir.int<s, 32>, !cir.float, !cir.double}>
 
 // Should generate unions with complex members.
 union U2 {
@@ -41,7 +41,7 @@ union U3 {
   short b;
   U u;
 } u3;
-// CHECK-DAG: !ty_22U322 = !cir.struct<union "U3" {!cir.int<s, 16>, !cir.struct<union "U" {!cir.bool, !cir.int<s, 16>, !cir.int<s, 32>, !cir.float, !cir.double}>} #cir.record.decl.ast>
+// CHECK-DAG: !ty_U3_ = !cir.struct<union "U3" {!cir.int<s, 16>, !cir.struct<union "U" {!cir.bool, !cir.int<s, 16>, !cir.int<s, 32>, !cir.float, !cir.double}>} #cir.record.decl.ast>
 
 void m() {
   yolm q;
@@ -50,31 +50,31 @@ void m() {
 }
 
 // CHECK:   cir.func @_Z1mv()
-// CHECK:   cir.alloca !ty_22yolm22, !cir.ptr<!ty_22yolm22>, ["q"] {alignment = 4 : i64}
-// CHECK:   cir.alloca !ty_22yolm222, !cir.ptr<!ty_22yolm222>, ["q2"] {alignment = 8 : i64}
-// CHECK:   cir.alloca !ty_22yolm322, !cir.ptr<!ty_22yolm322>, ["q3"] {alignment = 4 : i64}
+// CHECK:   cir.alloca !ty_yolm, !cir.ptr<!ty_yolm>, ["q"] {alignment = 4 : i64}
+// CHECK:   cir.alloca !ty_yolm2_, !cir.ptr<!ty_yolm2_>, ["q2"] {alignment = 8 : i64}
+// CHECK:   cir.alloca !ty_yolm3_, !cir.ptr<!ty_yolm3_>, ["q3"] {alignment = 4 : i64}
 
 void shouldGenerateUnionAccess(union U u) {
   u.b = true;
-  // CHECK: %[[#BASE:]] = cir.get_member %0[0] {name = "b"} : !cir.ptr<!ty_22U22> -> !cir.ptr<!cir.bool>
+  // CHECK: %[[#BASE:]] = cir.get_member %0[0] {name = "b"} : !cir.ptr<!ty_U> -> !cir.ptr<!cir.bool>
   // CHECK: cir.store %{{.+}}, %[[#BASE]] : !cir.bool, !cir.ptr<!cir.bool>
   u.b;
-  // CHECK: cir.get_member %0[0] {name = "b"} : !cir.ptr<!ty_22U22> -> !cir.ptr<!cir.bool>
+  // CHECK: cir.get_member %0[0] {name = "b"} : !cir.ptr<!ty_U> -> !cir.ptr<!cir.bool>
   u.i = 1;
-  // CHECK: %[[#BASE:]] = cir.get_member %0[2] {name = "i"} : !cir.ptr<!ty_22U22> -> !cir.ptr<!s32i>
+  // CHECK: %[[#BASE:]] = cir.get_member %0[2] {name = "i"} : !cir.ptr<!ty_U> -> !cir.ptr<!s32i>
   // CHECK: cir.store %{{.+}}, %[[#BASE]] : !s32i, !cir.ptr<!s32i>
   u.i;
-  // CHECK: %[[#BASE:]] = cir.get_member %0[2] {name = "i"} : !cir.ptr<!ty_22U22> -> !cir.ptr<!s32i>
+  // CHECK: %[[#BASE:]] = cir.get_member %0[2] {name = "i"} : !cir.ptr<!ty_U> -> !cir.ptr<!s32i>
   u.f = 0.1F;
-  // CHECK: %[[#BASE:]] = cir.get_member %0[3] {name = "f"} : !cir.ptr<!ty_22U22> -> !cir.ptr<!cir.float>
+  // CHECK: %[[#BASE:]] = cir.get_member %0[3] {name = "f"} : !cir.ptr<!ty_U> -> !cir.ptr<!cir.float>
   // CHECK: cir.store %{{.+}}, %[[#BASE]] : !cir.float, !cir.ptr<!cir.float>
   u.f;
-  // CHECK: %[[#BASE:]] = cir.get_member %0[3] {name = "f"} : !cir.ptr<!ty_22U22> -> !cir.ptr<!cir.float>
+  // CHECK: %[[#BASE:]] = cir.get_member %0[3] {name = "f"} : !cir.ptr<!ty_U> -> !cir.ptr<!cir.float>
   u.d = 0.1;
-  // CHECK: %[[#BASE:]] = cir.get_member %0[4] {name = "d"} : !cir.ptr<!ty_22U22> -> !cir.ptr<!cir.double>
+  // CHECK: %[[#BASE:]] = cir.get_member %0[4] {name = "d"} : !cir.ptr<!ty_U> -> !cir.ptr<!cir.double>
   // CHECK: cir.store %{{.+}}, %[[#BASE]] : !cir.double, !cir.ptr<!cir.double>
   u.d;
-  // CHECK: %[[#BASE:]] = cir.get_member %0[4] {name = "d"} : !cir.ptr<!ty_22U22> -> !cir.ptr<!cir.double>
+  // CHECK: %[[#BASE:]] = cir.get_member %0[4] {name = "d"} : !cir.ptr<!ty_U> -> !cir.ptr<!cir.double>
 }
 
 typedef union {
@@ -84,8 +84,8 @@ typedef union {
 
 void noCrushOnDifferentSizes() {
   A a = {0};
-  // CHECK:  %[[#TMP0:]] = cir.alloca !ty_22A22, !cir.ptr<!ty_22A22>, ["a"] {alignment = 4 : i64}
-  // CHECK:  %[[#TMP1:]] = cir.cast(bitcast, %[[#TMP0]] : !cir.ptr<!ty_22A22>), !cir.ptr<!ty_anon_struct>
+  // CHECK:  %[[#TMP0:]] = cir.alloca !ty_A, !cir.ptr<!ty_A>, ["a"] {alignment = 4 : i64}
+  // CHECK:  %[[#TMP1:]] = cir.cast(bitcast, %[[#TMP0]] : !cir.ptr<!ty_A>), !cir.ptr<!ty_anon_struct>
   // CHECK:  %[[#TMP2:]] = cir.const #cir.zero : !ty_anon_struct
   // CHECK:  cir.store %[[#TMP2]], %[[#TMP1]] : !ty_anon_struct, !cir.ptr<!ty_anon_struct>
 }
\ No newline at end of file
diff --git a/clang/test/CIR/CodeGen/var-arg-float.c b/clang/test/CIR/CodeGen/var-arg-float.c
index e3d49535b3a4..e1e2d413a528 100644
--- a/clang/test/CIR/CodeGen/var-arg-float.c
+++ b/clang/test/CIR/CodeGen/var-arg-float.c
@@ -12,26 +12,26 @@ double f1(int n, ...) {
   return res;
 }
 
-// BEFORE: !ty_22__va_list22 = !cir.struct<struct "__va_list" {!cir.ptr<!cir.void>, !cir.ptr<!cir.void>, !cir.ptr<!cir.void>, !cir.int<s, 32>, !cir.int<s, 32>}
+// BEFORE: !ty___va_list = !cir.struct<struct "__va_list" {!cir.ptr<!cir.void>, !cir.ptr<!cir.void>, !cir.ptr<!cir.void>, !cir.int<s, 32>, !cir.int<s, 32>}
 // BEFORE:  cir.func @f1(%arg0: !s32i, ...) -> !cir.double
 // BEFORE:  [[RETP:%.*]] = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["__retval"]
 // BEFORE:  [[RESP:%.*]] = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["res", init]
-// BEFORE:  cir.va.start [[VARLIST:%.*]] : !cir.ptr<!ty_22__va_list22>
-// BEFORE:  [[TMP0:%.*]] = cir.va.arg [[VARLIST]] : (!cir.ptr<!ty_22__va_list22>) -> !cir.double
+// BEFORE:  cir.va.start [[VARLIST:%.*]] : !cir.ptr<!ty___va_list>
+// BEFORE:  [[TMP0:%.*]] = cir.va.arg [[VARLIST]] : (!cir.ptr<!ty___va_list>) -> !cir.double
 // BEFORE:  cir.store [[TMP0]], [[RESP]] : !cir.double, !cir.ptr<!cir.double>
-// BEFORE:  cir.va.end [[VARLIST]] : !cir.ptr<!ty_22__va_list22>
+// BEFORE:  cir.va.end [[VARLIST]] : !cir.ptr<!ty___va_list>
 // BEFORE:  [[RES:%.*]] = cir.load [[RESP]] : !cir.ptr<!cir.double>, !cir.double
 // BEFORE:   cir.store [[RES]], [[RETP]] : !cir.double, !cir.ptr<!cir.double>
 // BEFORE:  [[RETV:%.*]] = cir.load [[RETP]] : !cir.ptr<!cir.double>, !cir.double
 // BEFORE:   cir.return [[RETV]] : !cir.double
 
 // beginning block cir code
-// AFTER: !ty_22__va_list22 = !cir.struct<struct "__va_list" {!cir.ptr<!cir.void>, !cir.ptr<!cir.void>, !cir.ptr<!cir.void>, !cir.int<s, 32>, !cir.int<s, 32>}
+// AFTER: !ty___va_list = !cir.struct<struct "__va_list" {!cir.ptr<!cir.void>, !cir.ptr<!cir.void>, !cir.ptr<!cir.void>, !cir.int<s, 32>, !cir.int<s, 32>}
 // AFTER:  cir.func @f1(%arg0: !s32i, ...) -> !cir.double
 // AFTER:  [[RETP:%.*]] = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["__retval"]
 // AFTER:  [[RESP:%.*]] = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["res", init]
-// AFTER:  cir.va.start [[VARLIST:%.*]] : !cir.ptr<!ty_22__va_list22>
-// AFTER:  [[VR_OFFS_P:%.*]] = cir.get_member [[VARLIST]][4] {name = "vr_offs"} : !cir.ptr<!ty_22__va_list22> -> !cir.ptr<!s32i>
+// AFTER:  cir.va.start [[VARLIST:%.*]] : !cir.ptr<!ty___va_list>
+// AFTER:  [[VR_OFFS_P:%.*]] = cir.get_member [[VARLIST]][4] {name = "vr_offs"} : !cir.ptr<!ty___va_list> -> !cir.ptr<!s32i>
 // AFTER:  [[VR_OFFS:%.*]] = cir.load [[VR_OFFS_P]] : !cir.ptr<!s32i>, !s32i
 // AFTER:  [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
 // AFTER:  [[CMP0:%.*]] = cir.cmp(ge, [[VR_OFFS]], [[ZERO]]) : !s32i, !cir.bool
@@ -46,7 +46,7 @@ double f1(int n, ...) {
 
 
 // AFTER: [[BB_IN_REG]]:
-// AFTER-NEXT: [[VR_TOP_P:%.*]] = cir.get_member [[VARLIST]][2] {name = "vr_top"} : !cir.ptr<!ty_22__va_list22> -> !cir.ptr<!cir.ptr<!void>>
+// AFTER-NEXT: [[VR_TOP_P:%.*]] = cir.get_member [[VARLIST]][2] {name = "vr_top"} : !cir.ptr<!ty___va_list> -> !cir.ptr<!cir.ptr<!void>>
 // AFTER-NEXT: [[VR_TOP:%.*]] = cir.load [[VR_TOP_P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // AFTER-NEXT: [[TMP2:%.*]] = cir.cast(bitcast, [[VR_TOP]] : !cir.ptr<!void>), !cir.ptr<i8>
 // AFTER-NEXT: [[TMP3:%.*]] = cir.ptr_stride([[TMP2]] : !cir.ptr<i8>, [[VR_OFFS]] : !s32i), !cir.ptr<i8>
@@ -55,7 +55,7 @@ double f1(int n, ...) {
 
 
 // AFTER: [[BB_ON_STACK]]:
-// AFTER-NEXT: [[STACK_P:%.*]] = cir.get_member [[VARLIST]][0] {name = "stack"} : !cir.ptr<!ty_22__va_list22> -> !cir.ptr<!cir.ptr<!void>>
+// AFTER-NEXT: [[STACK_P:%.*]] = cir.get_member [[VARLIST]][0] {name = "stack"} : !cir.ptr<!ty___va_list> -> !cir.ptr<!cir.ptr<!void>>
 // AFTER-NEXT: [[STACK_V:%.*]] = cir.load [[STACK_P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // AFTER-NEXT: [[EIGHT_IN_PTR_ARITH:%.*]]  = cir.const #cir.int<8> : !u64i
 // AFTER-NEXT: [[TMP4:%.*]] = cir.cast(bitcast, [[STACK_V]] : !cir.ptr<!void>), !cir.ptr<i8>
@@ -68,7 +68,7 @@ double f1(int n, ...) {
 // AFTER-NEXT:  [[TMP0:%.*]] = cir.cast(bitcast, [[BLK_ARG]] : !cir.ptr<!void>), !cir.ptr<!cir.double>
 // AFTER-NEXT:  [[TMP1:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.double>, !cir.double
 // AFTER:   cir.store [[TMP1]], [[RESP]] : !cir.double, !cir.ptr<!cir.double>
-// AFTER:   cir.va.end [[VARLIST]] : !cir.ptr<!ty_22__va_list22>
+// AFTER:   cir.va.end [[VARLIST]] : !cir.ptr<!ty___va_list>
 // AFTER:   [[RES:%.*]] = cir.load [[RESP]] : !cir.ptr<!cir.double>, !cir.double
 // AFTER:   cir.store [[RES]], [[RETP]] : !cir.double, !cir.ptr<!cir.double>
 // AFTER:  [[RETV:%.*]] = cir.load [[RETP]] : !cir.ptr<!cir.double>, !cir.double
diff --git a/clang/test/CIR/CodeGen/var-arg-scope.c b/clang/test/CIR/CodeGen/var-arg-scope.c
index 0829d0b8f81b..f5c3c65cd467 100644
--- a/clang/test/CIR/CodeGen/var-arg-scope.c
+++ b/clang/test/CIR/CodeGen/var-arg-scope.c
@@ -7,20 +7,20 @@ void f1(__builtin_va_list c) {
   { __builtin_va_arg(c, void *); }
 }
 
-// BEFORE: cir.func @f1(%arg0: !ty_22__va_list22) attributes
-// BEFORE: [[VAR_LIST:%.*]] = cir.alloca !ty_22__va_list22, !cir.ptr<!ty_22__va_list22>, ["c", init] {alignment = 8 : i64}
-// BEFORE: cir.store %arg0, [[VAR_LIST]] : !ty_22__va_list22, !cir.ptr<!ty_22__va_list22>
+// BEFORE: cir.func @f1(%arg0: !ty___va_list) attributes
+// BEFORE: [[VAR_LIST:%.*]] = cir.alloca !ty___va_list, !cir.ptr<!ty___va_list>, ["c", init] {alignment = 8 : i64}
+// BEFORE: cir.store %arg0, [[VAR_LIST]] : !ty___va_list, !cir.ptr<!ty___va_list>
 // BEFORE: cir.scope {
-// BEFORE-NEXT: [[TMP:%.*]] = cir.va.arg [[VAR_LIST]] : (!cir.ptr<!ty_22__va_list22>) -> !cir.ptr<!void>
+// BEFORE-NEXT: [[TMP:%.*]] = cir.va.arg [[VAR_LIST]] : (!cir.ptr<!ty___va_list>) -> !cir.ptr<!void>
 // BEFORE-NEXT: }
 // BEFORE-NEXT: cir.return
 
-// AFTER: cir.func @f1(%arg0: !ty_22__va_list22) attributes
-// AFTER: [[VARLIST:%.*]] = cir.alloca !ty_22__va_list22, !cir.ptr<!ty_22__va_list22>, ["c", init] {alignment = 8 : i64}
-// AFTER: cir.store %arg0, [[VARLIST]] : !ty_22__va_list22, !cir.ptr<!ty_22__va_list22>
+// AFTER: cir.func @f1(%arg0: !ty___va_list) attributes
+// AFTER: [[VARLIST:%.*]] = cir.alloca !ty___va_list, !cir.ptr<!ty___va_list>, ["c", init] {alignment = 8 : i64}
+// AFTER: cir.store %arg0, [[VARLIST]] : !ty___va_list, !cir.ptr<!ty___va_list>
 // AFTER: cir.scope {
 //
-// AFTER-NEXT: [[GR_OFFS_P:%.*]] = cir.get_member [[VARLIST]][3] {name = "gr_offs"} : !cir.ptr<!ty_22__va_list22> -> !cir.ptr<!s32i>
+// AFTER-NEXT: [[GR_OFFS_P:%.*]] = cir.get_member [[VARLIST]][3] {name = "gr_offs"} : !cir.ptr<!ty___va_list> -> !cir.ptr<!s32i>
 // AFTER-NEXT: [[GR_OFFS:%.*]] = cir.load [[GR_OFFS_P]] : !cir.ptr<!s32i>
 // AFTER:  [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
 // AFTER:  [[CMP0:%.*]] = cir.cmp(ge, [[GR_OFFS]], [[ZERO]]) : !s32i, !cir.bool
@@ -36,7 +36,7 @@ void f1(__builtin_va_list c) {
 
 // arg is passed in register.
 // AFTER: [[BB_IN_REG]]:
-// AFTER-NEXT: [[GR_TOP_P:%.*]] = cir.get_member [[VARLIST]][1] {name = "gr_top"} : !cir.ptr<!ty_22__va_list22> -> !cir.ptr<!cir.ptr<!void>>
+// AFTER-NEXT: [[GR_TOP_P:%.*]] = cir.get_member [[VARLIST]][1] {name = "gr_top"} : !cir.ptr<!ty___va_list> -> !cir.ptr<!cir.ptr<!void>>
 // AFTER-NEXT: [[GR_TOP:%.*]] = cir.load [[GR_TOP_P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // AFTER-NEXT: [[TMP2:%.*]] = cir.cast(bitcast, [[GR_TOP]] : !cir.ptr<!void>), !cir.ptr<i8>
 // AFTER-NEXT: [[TMP3:%.*]] = cir.ptr_stride([[TMP2]] : !cir.ptr<i8>, [[GR_OFFS]] : !s32i), !cir.ptr<i8>
@@ -45,7 +45,7 @@ void f1(__builtin_va_list c) {
 
 // arg is passed in stack.
 // AFTER: [[BB_ON_STACK]]:
-// AFTER-NEXT: [[STACK_P:%.*]] = cir.get_member [[VARLIST]][0] {name = "stack"} : !cir.ptr<!ty_22__va_list22> -> !cir.ptr<!cir.ptr<!void>>
+// AFTER-NEXT: [[STACK_P:%.*]] = cir.get_member [[VARLIST]][0] {name = "stack"} : !cir.ptr<!ty___va_list> -> !cir.ptr<!cir.ptr<!void>>
 // AFTER-NEXT: [[STACK_V:%.*]] = cir.load [[STACK_P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // AFTER-NEXT: [[EIGHT_IN_PTR_ARITH:%.*]]  = cir.const #cir.int<8> : !u64i
 // AFTER-NEXT: [[TMP4:%.*]] = cir.cast(bitcast, [[STACK_V]] : !cir.ptr<!void>), !cir.ptr<i8>
diff --git a/clang/test/CIR/CodeGen/var-arg.c b/clang/test/CIR/CodeGen/var-arg.c
index 3b58c94dbd3b..e689adefebe5 100644
--- a/clang/test/CIR/CodeGen/var-arg.c
+++ b/clang/test/CIR/CodeGen/var-arg.c
@@ -12,25 +12,25 @@ int f1(int n, ...) {
   return res;
 }
 
-// BEFORE: !ty_22__va_list22 = !cir.struct<struct "__va_list" {!cir.ptr<!cir.void>, !cir.ptr<!cir.void>, !cir.ptr<!cir.void>, !cir.int<s, 32>, !cir.int<s, 32>}
+// BEFORE: !ty___va_list = !cir.struct<struct "__va_list" {!cir.ptr<!cir.void>, !cir.ptr<!cir.void>, !cir.ptr<!cir.void>, !cir.int<s, 32>, !cir.int<s, 32>}
 // BEFORE:  cir.func @f1(%arg0: !s32i, ...) -> !s32i
 // BEFORE:  [[RETP:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
 // BEFORE:  [[RESP:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["res", init]
-// BEFORE:  cir.va.start [[VARLIST:%.*]] : !cir.ptr<!ty_22__va_list22>
-// BEFORE:  [[TMP0:%.*]] = cir.va.arg [[VARLIST]] : (!cir.ptr<!ty_22__va_list22>) -> !s32i
+// BEFORE:  cir.va.start [[VARLIST:%.*]] : !cir.ptr<!ty___va_list>
+// BEFORE:  [[TMP0:%.*]] = cir.va.arg [[VARLIST]] : (!cir.ptr<!ty___va_list>) -> !s32i
 // BEFORE:  cir.store [[TMP0]], [[RESP]] : !s32i, !cir.ptr<!s32i>
-// BEFORE:  cir.va.end [[VARLIST]] : !cir.ptr<!ty_22__va_list22>
+// BEFORE:  cir.va.end [[VARLIST]] : !cir.ptr<!ty___va_list>
 // BEFORE:  [[RES:%.*]] = cir.load [[RESP]] : !cir.ptr<!s32i>, !s32i
 // BEFORE:   cir.store [[RES]], [[RETP]] : !s32i, !cir.ptr<!s32i>
 // BEFORE:  [[RETV:%.*]] = cir.load [[RETP]] : !cir.ptr<!s32i>, !s32i
 // BEFORE:   cir.return [[RETV]] : !s32i
 
-// AFTER: !ty_22__va_list22 = !cir.struct<struct "__va_list" {!cir.ptr<!cir.void>, !cir.ptr<!cir.void>, !cir.ptr<!cir.void>, !cir.int<s, 32>, !cir.int<s, 32>}
+// AFTER: !ty___va_list = !cir.struct<struct "__va_list" {!cir.ptr<!cir.void>, !cir.ptr<!cir.void>, !cir.ptr<!cir.void>, !cir.int<s, 32>, !cir.int<s, 32>}
 // AFTER:  cir.func @f1(%arg0: !s32i, ...) -> !s32i
 // AFTER:  [[RETP:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
 // AFTER:  [[RESP:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["res", init]
-// AFTER:  cir.va.start [[VARLIST:%.*]] : !cir.ptr<!ty_22__va_list22>
-// AFTER:  [[GR_OFFS_P:%.*]] = cir.get_member [[VARLIST]][3] {name = "gr_offs"} : !cir.ptr<!ty_22__va_list22> -> !cir.ptr<!s32i>
+// AFTER:  cir.va.start [[VARLIST:%.*]] : !cir.ptr<!ty___va_list>
+// AFTER:  [[GR_OFFS_P:%.*]] = cir.get_member [[VARLIST]][3] {name = "gr_offs"} : !cir.ptr<!ty___va_list> -> !cir.ptr<!s32i>
 // AFTER:  [[GR_OFFS:%.*]] = cir.load [[GR_OFFS_P]] : !cir.ptr<!s32i>, !s32i
 // AFTER:  [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
 // AFTER:  [[CMP0:%.*]] = cir.cmp(ge, [[GR_OFFS]], [[ZERO]]) : !s32i, !cir.bool
@@ -46,7 +46,7 @@ int f1(int n, ...) {
 
 // arg is passed in register.
 // AFTER: [[BB_IN_REG]]:
-// AFTER-NEXT: [[GR_TOP_P:%.*]] = cir.get_member [[VARLIST]][1] {name = "gr_top"} : !cir.ptr<!ty_22__va_list22> -> !cir.ptr<!cir.ptr<!void>>
+// AFTER-NEXT: [[GR_TOP_P:%.*]] = cir.get_member [[VARLIST]][1] {name = "gr_top"} : !cir.ptr<!ty___va_list> -> !cir.ptr<!cir.ptr<!void>>
 // AFTER-NEXT: [[GR_TOP:%.*]] = cir.load [[GR_TOP_P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // AFTER-NEXT: [[TMP2:%.*]] = cir.cast(bitcast, [[GR_TOP]] : !cir.ptr<!void>), !cir.ptr<i8>
 // AFTER-NEXT: [[TMP3:%.*]] = cir.ptr_stride([[TMP2]] : !cir.ptr<i8>, [[GR_OFFS]] : !s32i), !cir.ptr<i8>
@@ -55,7 +55,7 @@ int f1(int n, ...) {
 
 // arg is passed in stack.
 // AFTER: [[BB_ON_STACK]]:
-// AFTER-NEXT: [[STACK_P:%.*]] = cir.get_member [[VARLIST]][0] {name = "stack"} : !cir.ptr<!ty_22__va_list22> -> !cir.ptr<!cir.ptr<!void>>
+// AFTER-NEXT: [[STACK_P:%.*]] = cir.get_member [[VARLIST]][0] {name = "stack"} : !cir.ptr<!ty___va_list> -> !cir.ptr<!cir.ptr<!void>>
 // AFTER-NEXT: [[STACK_V:%.*]] = cir.load [[STACK_P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // AFTER-NEXT: [[EIGHT_IN_PTR_ARITH:%.*]]  = cir.const #cir.int<8> : !u64i
 // AFTER-NEXT: [[TMP4:%.*]] = cir.cast(bitcast, [[STACK_V]] : !cir.ptr<!void>), !cir.ptr<i8>
@@ -72,7 +72,7 @@ int f1(int n, ...) {
 // AFTER-NEXT:  [[TMP0:%.*]] = cir.cast(bitcast, [[BLK_ARG]] : !cir.ptr<!void>), !cir.ptr<!s32i>
 // AFTER-NEXT:  [[TMP1:%.*]] = cir.load [[TMP0]] : !cir.ptr<!s32i>, !s32i
 // AFTER:   cir.store [[TMP1]], [[RESP]] : !s32i, !cir.ptr<!s32i>
-// AFTER:   cir.va.end [[VARLIST]] : !cir.ptr<!ty_22__va_list22>
+// AFTER:   cir.va.end [[VARLIST]] : !cir.ptr<!ty___va_list>
 // AFTER:   [[RES:%.*]] = cir.load [[RESP]] : !cir.ptr<!s32i>, !s32i
 // AFTER:   cir.store [[RES]], [[RETP]] : !s32i, !cir.ptr<!s32i>
 // AFTER:  [[RETV:%.*]] = cir.load [[RETP]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/CodeGen/vector.cpp b/clang/test/CIR/CodeGen/vector.cpp
index 2ff9dfceacae..ad99c6e4fe6a 100644
--- a/clang/test/CIR/CodeGen/vector.cpp
+++ b/clang/test/CIR/CodeGen/vector.cpp
@@ -12,13 +12,13 @@ namespace std {
 } // namespace std
 
 // CHECK: cir.func linkonce_odr @_ZNSt6vectorIyE6resizeEm(
-// CHECK:   %0 = cir.alloca !cir.ptr<!ty_22std3A3Avector3Cunsigned_long_long3E22>, !cir.ptr<!cir.ptr<!ty_22std3A3Avector3Cunsigned_long_long3E22>>, ["this", init] {alignment = 8 : i64}
+// CHECK:   %0 = cir.alloca !cir.ptr<!ty_std3A3Avector3Cunsigned_long_long3E>, !cir.ptr<!cir.ptr<!ty_std3A3Avector3Cunsigned_long_long3E>>, ["this", init] {alignment = 8 : i64}
 // CHECK:   %1 = cir.alloca !u64i, !cir.ptr<!u64i>, ["__sz", init] {alignment = 8 : i64}
 // CHECK:   %2 = cir.alloca !u64i, !cir.ptr<!u64i>, ["__cs", init] {alignment = 8 : i64}
-// CHECK:   cir.store %arg0, %0 : !cir.ptr<!ty_22std3A3Avector3Cunsigned_long_long3E22>, !cir.ptr<!cir.ptr<!ty_22std3A3Avector3Cunsigned_long_long3E22>>
+// CHECK:   cir.store %arg0, %0 : !cir.ptr<!ty_std3A3Avector3Cunsigned_long_long3E>, !cir.ptr<!cir.ptr<!ty_std3A3Avector3Cunsigned_long_long3E>>
 // CHECK:   cir.store %arg1, %1 : !u64i, !cir.ptr<!u64i>
-// CHECK:   %3 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22std3A3Avector3Cunsigned_long_long3E22>>, !cir.ptr<!ty_22std3A3Avector3Cunsigned_long_long3E22>
-// CHECK:   %4 = cir.call @_ZNKSt6vectorIyE4sizeEv(%3) : (!cir.ptr<!ty_22std3A3Avector3Cunsigned_long_long3E22>) -> !u64i
+// CHECK:   %3 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_std3A3Avector3Cunsigned_long_long3E>>, !cir.ptr<!ty_std3A3Avector3Cunsigned_long_long3E>
+// CHECK:   %4 = cir.call @_ZNKSt6vectorIyE4sizeEv(%3) : (!cir.ptr<!ty_std3A3Avector3Cunsigned_long_long3E>) -> !u64i
 // CHECK:   cir.store %4, %2 : !u64i, !cir.ptr<!u64i>
 // CHECK:   cir.scope {
 // CHECK:     %5 = cir.load %2 : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGen/vtable-rtti.cpp b/clang/test/CIR/CodeGen/vtable-rtti.cpp
index db93a4060d20..7e684df2bb58 100644
--- a/clang/test/CIR/CodeGen/vtable-rtti.cpp
+++ b/clang/test/CIR/CodeGen/vtable-rtti.cpp
@@ -54,7 +54,7 @@ class B : public A
 //
 // CHECK: cir.func @_Z3foov()
 // CHECK:   cir.scope {
-// CHECK:     %0 = cir.alloca !ty_22B22, !cir.ptr<!ty_22B22>, ["agg.tmp.ensured"] {alignment = 8 : i64}
+// CHECK:     %0 = cir.alloca !ty_B, !cir.ptr<!ty_B>, ["agg.tmp.ensured"] {alignment = 8 : i64}
 // CHECK:     %1 = cir.const #cir.zero : ![[ClassB]]
 // CHECK:     cir.store %1, %0 : ![[ClassB]], !cir.ptr<![[ClassB]]>
 // CHECK:     cir.call @_ZN1BC2Ev(%0) : (!cir.ptr<![[ClassB]]>) -> ()
diff --git a/clang/test/CIR/IR/data-member-ptr.cir b/clang/test/CIR/IR/data-member-ptr.cir
index a05193c21108..7078510bc594 100644
--- a/clang/test/CIR/IR/data-member-ptr.cir
+++ b/clang/test/CIR/IR/data-member-ptr.cir
@@ -1,17 +1,17 @@
 // RUN: cir-opt %s | cir-opt | FileCheck %s
 
 !s32i = !cir.int<s, 32>
-!ty_22Foo22 = !cir.struct<struct "Foo" {!s32i}>
+!ty_Foo = !cir.struct<struct "Foo" {!s32i}>
 
 module {
   cir.func @null_member() {
-    %0 = cir.const #cir.data_member<null> : !cir.data_member<!s32i in !ty_22Foo22>
+    %0 = cir.const #cir.data_member<null> : !cir.data_member<!s32i in !ty_Foo>
     cir.return
   }
 
-  cir.func @get_runtime_member(%arg0: !cir.ptr<!ty_22Foo22>) {
-    %0 = cir.const #cir.data_member<0> : !cir.data_member<!s32i in !ty_22Foo22>
-    %1 = cir.get_runtime_member %arg0[%0 : !cir.data_member<!s32i in !ty_22Foo22>] : !cir.ptr<!ty_22Foo22> -> !cir.ptr<!s32i>
+  cir.func @get_runtime_member(%arg0: !cir.ptr<!ty_Foo>) {
+    %0 = cir.const #cir.data_member<0> : !cir.data_member<!s32i in !ty_Foo>
+    %1 = cir.get_runtime_member %arg0[%0 : !cir.data_member<!s32i in !ty_Foo>] : !cir.ptr<!ty_Foo> -> !cir.ptr<!s32i>
     cir.return
   }
 }
@@ -19,13 +19,13 @@ module {
 //      CHECK: module {
 
 // CHECK-NEXT:   cir.func @null_member() {
-// CHECK-NEXT:     %0 = cir.const #cir.data_member<null> : !cir.data_member<!s32i in !ty_22Foo22>
+// CHECK-NEXT:     %0 = cir.const #cir.data_member<null> : !cir.data_member<!s32i in !ty_Foo>
 // CHECK-NEXT:     cir.return
 // CHECK-NEXT:   }
 
-// CHECK-NEXT:   cir.func @get_runtime_member(%arg0: !cir.ptr<!ty_22Foo22>) {
-// CHECK-NEXT:      %0 = cir.const #cir.data_member<0> : !cir.data_member<!s32i in !ty_22Foo22>
-// CHECK-NEXT:      %1 = cir.get_runtime_member %arg0[%0 : !cir.data_member<!s32i in !ty_22Foo22>] : !cir.ptr<!ty_22Foo22> -> !cir.ptr<!s32i>
+// CHECK-NEXT:   cir.func @get_runtime_member(%arg0: !cir.ptr<!ty_Foo>) {
+// CHECK-NEXT:      %0 = cir.const #cir.data_member<0> : !cir.data_member<!s32i in !ty_Foo>
+// CHECK-NEXT:      %1 = cir.get_runtime_member %arg0[%0 : !cir.data_member<!s32i in !ty_Foo>] : !cir.ptr<!ty_Foo> -> !cir.ptr<!s32i>
 // CHECK-NEXT:      cir.return
 // CHECK-NEXT:   }
 
diff --git a/clang/test/CIR/IR/getmember.cir b/clang/test/CIR/IR/getmember.cir
index 5bfd8f24d161..d9cecc0dea9c 100644
--- a/clang/test/CIR/IR/getmember.cir
+++ b/clang/test/CIR/IR/getmember.cir
@@ -4,21 +4,21 @@
 !u16i = !cir.int<u, 16>
 !u32i = !cir.int<u, 32>
 
-!ty_22Class22 = !cir.struct<class "Class" {!u16i, !u32i}>
-!ty_22Incomplete22 = !cir.struct<struct "Incomplete" incomplete>
-!ty_22Struct22 = !cir.struct<struct "Struct" {!u16i, !u32i}>
+!ty_Class = !cir.struct<class "Class" {!u16i, !u32i}>
+!ty_Incomplete = !cir.struct<struct "Incomplete" incomplete>
+!ty_Struct = !cir.struct<struct "Struct" {!u16i, !u32i}>
 
 module  {
-  cir.func @shouldGetStructMember(%arg0 : !cir.ptr<!ty_22Struct22>) {
-    // CHECK: cir.get_member %arg0[1] {name = "test"} : !cir.ptr<!ty_22Struct22> -> !cir.ptr<!u32i>
-    %0 = cir.get_member %arg0[1] {name = "test"} : !cir.ptr<!ty_22Struct22> -> !cir.ptr<!u32i>
+  cir.func @shouldGetStructMember(%arg0 : !cir.ptr<!ty_Struct>) {
+    // CHECK: cir.get_member %arg0[1] {name = "test"} : !cir.ptr<!ty_Struct> -> !cir.ptr<!u32i>
+    %0 = cir.get_member %arg0[1] {name = "test"} : !cir.ptr<!ty_Struct> -> !cir.ptr<!u32i>
     cir.return
   }
 
   // FIXME: remove bypass once codegen for CIR class records is patched.
-  cir.func @shouldBypassMemberTypeCheckForClassRecords(%arg0 : !cir.ptr<!ty_22Class22>) {
-    // CHECK: cir.get_member %arg0[1] {name = "test"} : !cir.ptr<!ty_22Class22> -> !cir.ptr<!cir.ptr<!u32i>> 
-    %0 = cir.get_member %arg0[1] {name = "test"} : !cir.ptr<!ty_22Class22> -> !cir.ptr<!cir.ptr<!u32i>>
+  cir.func @shouldBypassMemberTypeCheckForClassRecords(%arg0 : !cir.ptr<!ty_Class>) {
+    // CHECK: cir.get_member %arg0[1] {name = "test"} : !cir.ptr<!ty_Class> -> !cir.ptr<!cir.ptr<!u32i>> 
+    %0 = cir.get_member %arg0[1] {name = "test"} : !cir.ptr<!ty_Class> -> !cir.ptr<!cir.ptr<!u32i>>
     cir.return
   }
 }
diff --git a/clang/test/CIR/IR/global.cir b/clang/test/CIR/IR/global.cir
index ad8bba6a9410..cb75684886af 100644
--- a/clang/test/CIR/IR/global.cir
+++ b/clang/test/CIR/IR/global.cir
@@ -3,7 +3,7 @@
 !s8i = !cir.int<s, 8>
 !s32i = !cir.int<s, 32>
 !s64i = !cir.int<s, 64>
-!ty_22Init22 = !cir.struct<class "Init" {!s8i} #cir.record.decl.ast>
+!ty_Init = !cir.struct<class "Init" {!s8i} #cir.record.decl.ast>
 module {
   cir.global external @a = #cir.int<3> : !s32i
   cir.global external @rgb = #cir.const_array<[#cir.int<0> : !s8i, #cir.int<-23> : !s8i, #cir.int<33> : !s8i] : !cir.array<!s8i x 3>>
@@ -32,15 +32,15 @@ module {
     #cir.global_view<@type_info_name_B> : !cir.ptr<!s8i>,
     #cir.global_view<@type_info_A> : !cir.ptr<!s8i>}>
   : !cir.struct<struct {!cir.ptr<!s8i>, !cir.ptr<!s8i>, !cir.ptr<!s8i>}>
-  cir.func private @_ZN4InitC1Eb(!cir.ptr<!ty_22Init22>, !s8i)
-  cir.func private @_ZN4InitD1Ev(!cir.ptr<!ty_22Init22>)
-  cir.global "private" internal @_ZL8__ioinit = ctor : !ty_22Init22 {
-    %0 = cir.get_global @_ZL8__ioinit : !cir.ptr<!ty_22Init22>
+  cir.func private @_ZN4InitC1Eb(!cir.ptr<!ty_Init>, !s8i)
+  cir.func private @_ZN4InitD1Ev(!cir.ptr<!ty_Init>)
+  cir.global "private" internal @_ZL8__ioinit = ctor : !ty_Init {
+    %0 = cir.get_global @_ZL8__ioinit : !cir.ptr<!ty_Init>
     %1 = cir.const #cir.int<3> : !s8i
-    cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr<!ty_22Init22>, !s8i) -> ()
+    cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr<!ty_Init>, !s8i) -> ()
   } dtor {
-    %0 = cir.get_global @_ZL8__ioinit : !cir.ptr<!ty_22Init22>
-    cir.call @_ZN4InitD1Ev(%0) : (!cir.ptr<!ty_22Init22>) -> ()
+    %0 = cir.get_global @_ZL8__ioinit : !cir.ptr<!ty_Init>
+    cir.call @_ZN4InitD1Ev(%0) : (!cir.ptr<!ty_Init>) -> ()
   }
 
   cir.func @f31() global_ctor {
@@ -87,10 +87,10 @@ module {
 // CHECK: cir.func @use_global()
 // CHECK-NEXT: %0 = cir.get_global @a : !cir.ptr<!s32i>
 
-// CHECK:      cir.global "private" internal @_ZL8__ioinit = ctor : !ty_22Init22 {
-// CHECK-NEXT:  %0 = cir.get_global @_ZL8__ioinit : !cir.ptr<!ty_22Init22>
+// CHECK:      cir.global "private" internal @_ZL8__ioinit = ctor : !ty_Init {
+// CHECK-NEXT:  %0 = cir.get_global @_ZL8__ioinit : !cir.ptr<!ty_Init>
 // CHECK-NEXT:  %1 = cir.const #cir.int<3> : !s8i
-// CHECK-NEXT:  cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr<!ty_22Init22>, !s8i) -> ()
+// CHECK-NEXT:  cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr<!ty_Init>, !s8i) -> ()
 // CHECK-NEXT: }
 
 // CHECK: cir.func @f31() global_ctor
diff --git a/clang/test/CIR/IR/invalid.cir b/clang/test/CIR/IR/invalid.cir
index 2473082b9334..855922d3d701 100644
--- a/clang/test/CIR/IR/invalid.cir
+++ b/clang/test/CIR/IR/invalid.cir
@@ -736,9 +736,9 @@ module {
 
 // -----
 !s8i = !cir.int<s, 8>
-!ty_22Init22 = !cir.struct<class "Init" {!s8i} #cir.record.decl.ast>
+!ty_Init = !cir.struct<class "Init" {!s8i} #cir.record.decl.ast>
 module {
-  cir.global "private" internal @_ZL8__ioinit = ctor : !ty_22Init22 {
+  cir.global "private" internal @_ZL8__ioinit = ctor : !ty_Init {
   }
   // expected-error@+1 {{custom op 'cir.global' ctor region must have exactly one block}}
 }
@@ -746,12 +746,12 @@ module {
 // -----
 !s8i = !cir.int<s, 8>
 #true = #cir.bool<true> : !cir.bool
-!ty_22Init22 = !cir.struct<class "Init" {!s8i} #cir.record.decl.ast>
+!ty_Init = !cir.struct<class "Init" {!s8i} #cir.record.decl.ast>
 module {
-  cir.func private @_ZN4InitC1Eb(!cir.ptr<!ty_22Init22>)
-  cir.global "private" internal @_ZL8__ioinit = ctor : !ty_22Init22 {
-    %0 = cir.get_global @_ZL8__ioinit : !cir.ptr<!ty_22Init22>
-    cir.call @_ZN4InitC1Eb(%0) : (!cir.ptr<!ty_22Init22>) -> ()
+  cir.func private @_ZN4InitC1Eb(!cir.ptr<!ty_Init>)
+  cir.global "private" internal @_ZL8__ioinit = ctor : !ty_Init {
+    %0 = cir.get_global @_ZL8__ioinit : !cir.ptr<!ty_Init>
+    cir.call @_ZN4InitC1Eb(%0) : (!cir.ptr<!ty_Init>) -> ()
   } dtor {}
   // expected-error@+1 {{custom op 'cir.global' dtor region must have exactly one block}}
 }
diff --git a/clang/test/CIR/IR/struct.cir b/clang/test/CIR/IR/struct.cir
index abaaf8766e4b..a793e38b1a92 100644
--- a/clang/test/CIR/IR/struct.cir
+++ b/clang/test/CIR/IR/struct.cir
@@ -8,18 +8,18 @@
 
 !ty_2222 = !cir.struct<struct {!cir.array<!cir.ptr<!u8i> x 5>}>
 !ty_22221 = !cir.struct<struct {!cir.ptr<!u8i>, !cir.ptr<!u8i>, !cir.ptr<!u8i>}>
-!ty_22A22 = !cir.struct<class "A" incomplete #cir.record.decl.ast>
-!ty_22i22 = !cir.struct<union "i" incomplete>
-!ty_22S22 = !cir.struct<struct "S" {!u8i, !u16i, !u32i}>
-!ty_22S122 = !cir.struct<struct "S1" {!s32i, !s32i}>
+!ty_A = !cir.struct<class "A" incomplete #cir.record.decl.ast>
+!ty_i = !cir.struct<union "i" incomplete>
+!ty_S = !cir.struct<struct "S" {!u8i, !u16i, !u32i}>
+!ty_S1_ = !cir.struct<struct "S1" {!s32i, !s32i}>
 
 // Test recursive struct parsing/printing.
-!ty_22Node22 = !cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node">>} #cir.record.decl.ast>
+!ty_Node = !cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node">>} #cir.record.decl.ast>
 // CHECK-DAG: !cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node">>} #cir.record.decl.ast>
 
 module  {
   // Dummy function to use types and force them to be printed.
-  cir.func @useTypes(%arg0: !ty_22Node22) {
+  cir.func @useTypes(%arg0: !ty_Node) {
     cir.return
   }
 
@@ -30,12 +30,12 @@ module  {
   }
 
 // CHECK: cir.func @structs() {
-// CHECK:     %0 = cir.alloca !cir.ptr<!ty_22S22>, !cir.ptr<!cir.ptr<!ty_22S22>>, ["s", init]
-// CHECK:     %1 = cir.alloca !cir.ptr<!ty_22i22>, !cir.ptr<!cir.ptr<!ty_22i22>>, ["i", init]
+// CHECK:     %0 = cir.alloca !cir.ptr<!ty_S>, !cir.ptr<!cir.ptr<!ty_S>>, ["s", init]
+// CHECK:     %1 = cir.alloca !cir.ptr<!ty_i>, !cir.ptr<!cir.ptr<!ty_i>>, ["i", init]
 
   cir.func @shouldSuccessfullyParseConstStructAttrs() {
-    %0 = cir.const #cir.const_struct<{#cir.int<1> : !s32i, #cir.int<2> : !s32i}> : !ty_22S122
-    // CHECK: cir.const #cir.const_struct<{#cir.int<1> : !s32i, #cir.int<2> : !s32i}> : !ty_22S122
+    %0 = cir.const #cir.const_struct<{#cir.int<1> : !s32i, #cir.int<2> : !s32i}> : !ty_S1_
+    // CHECK: cir.const #cir.const_struct<{#cir.int<1> : !s32i, #cir.int<2> : !s32i}> : !ty_S1_
     cir.return
   }
 }
diff --git a/clang/test/CIR/Lowering/ThroughMLIR/vtable.cir b/clang/test/CIR/Lowering/ThroughMLIR/vtable.cir
index c1e985cd3e2c..66eb06629793 100644
--- a/clang/test/CIR/Lowering/ThroughMLIR/vtable.cir
+++ b/clang/test/CIR/Lowering/ThroughMLIR/vtable.cir
@@ -13,34 +13,34 @@
 !ty_anon_struct2 = !cir.struct<struct  {!cir.array<!cir.ptr<!cir.int<u, 8>> x 4>}>
 !ty_anon_struct3 = !cir.struct<struct  {!cir.array<!cir.ptr<!cir.int<u, 8>> x 3>}>
 !ty_anon_struct4 = !cir.struct<struct  {!cir.array<!cir.ptr<!cir.int<u, 8>> x 4>, !cir.array<!cir.ptr<!cir.int<u, 8>> x 3>}>
-!ty_22Father22 = !cir.struct<class "Father" {!cir.ptr<!cir.ptr<!cir.func<!cir.int<u, 32> ()>>>} #cir.record.decl.ast>
-!ty_22Mother22 = !cir.struct<class "Mother" {!cir.ptr<!cir.ptr<!cir.func<!cir.int<u, 32> ()>>>} #cir.record.decl.ast>
-!ty_22Child22 = !cir.struct<class "Child" {!cir.struct<class "Mother" {!cir.ptr<!cir.ptr<!cir.func<!cir.int<u, 32> ()>>>} #cir.record.decl.ast>, !cir.struct<class "Father" {!cir.ptr<!cir.ptr<!cir.func<!cir.int<u, 32> ()>>>} #cir.record.decl.ast>} #cir.record.decl.ast>
+!ty_Father = !cir.struct<class "Father" {!cir.ptr<!cir.ptr<!cir.func<!cir.int<u, 32> ()>>>} #cir.record.decl.ast>
+!ty_Mother = !cir.struct<class "Mother" {!cir.ptr<!cir.ptr<!cir.func<!cir.int<u, 32> ()>>>} #cir.record.decl.ast>
+!ty_Child = !cir.struct<class "Child" {!cir.struct<class "Mother" {!cir.ptr<!cir.ptr<!cir.func<!cir.int<u, 32> ()>>>} #cir.record.decl.ast>, !cir.struct<class "Father" {!cir.ptr<!cir.ptr<!cir.func<!cir.int<u, 32> ()>>>} #cir.record.decl.ast>} #cir.record.decl.ast>
 
 module {
-  cir.func linkonce_odr @_ZN6Mother6simpleEv(%arg0: !cir.ptr<!ty_22Mother22>) { 
-    %0 = cir.alloca !cir.ptr<!ty_22Mother22>, !cir.ptr<!cir.ptr<!ty_22Mother22>>, ["this", init] {alignment = 8 : i64}
-    cir.store %arg0, %0 : !cir.ptr<!ty_22Mother22>, !cir.ptr<!cir.ptr<!ty_22Mother22>>
-    %1 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_22Mother22>>, !cir.ptr<!ty_22Mother22>
+  cir.func linkonce_odr @_ZN6Mother6simpleEv(%arg0: !cir.ptr<!ty_Mother>) { 
+    %0 = cir.alloca !cir.ptr<!ty_Mother>, !cir.ptr<!cir.ptr<!ty_Mother>>, ["this", init] {alignment = 8 : i64}
+    cir.store %arg0, %0 : !cir.ptr<!ty_Mother>, !cir.ptr<!cir.ptr<!ty_Mother>>
+    %1 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_Mother>>, !cir.ptr<!ty_Mother>
     cir.return 
   }
-  cir.func private @_ZN5ChildC2Ev(%arg0: !cir.ptr<!ty_22Child22>) { cir.return }
+  cir.func private @_ZN5ChildC2Ev(%arg0: !cir.ptr<!ty_Child>) { cir.return }
   cir.global linkonce_odr @_ZTV6Mother = #cir.vtable<{#cir.const_array<[#cir.ptr<null> : !cir.ptr<!u8i>, #cir.global_view<@_ZTI6Mother> : !cir.ptr<!u8i>, #cir.global_view<@_ZN6Mother9MotherFooEv> : !cir.ptr<!u8i>, #cir.global_view<@_ZN6Mother10MotherFoo2Ev> : !cir.ptr<!u8i>]> : !cir.array<!cir.ptr<!u8i> x 4>}> : !ty_anon_struct2 {alignment = 8 : i64} 
   cir.global "private" external @_ZTVN10__cxxabiv117__class_type_infoE : !cir.ptr<!cir.ptr<!u8i>> 
   cir.global linkonce_odr @_ZTS6Mother = #cir.const_array<"6Mother" : !cir.array<!s8i x 7>> : !cir.array<!s8i x 7> {alignment = 1 : i64} 
   cir.global constant external @_ZTI6Mother = #cir.typeinfo<{#cir.global_view<@_ZTVN10__cxxabiv117__class_type_infoE, [2 : i32]> : !cir.ptr<!u8i>, #cir.global_view<@_ZTS6Mother> : !cir.ptr<!u8i>}> : !ty_anon_struct {alignment = 8 : i64} 
-  cir.func linkonce_odr @_ZN6Mother9MotherFooEv(%arg0: !cir.ptr<!ty_22Mother22> ) { cir.return }
-  cir.func linkonce_odr @_ZN6Mother10MotherFoo2Ev(%arg0: !cir.ptr<!ty_22Mother22> ) { cir.return }
+  cir.func linkonce_odr @_ZN6Mother9MotherFooEv(%arg0: !cir.ptr<!ty_Mother> ) { cir.return }
+  cir.func linkonce_odr @_ZN6Mother10MotherFoo2Ev(%arg0: !cir.ptr<!ty_Mother> ) { cir.return }
   cir.global linkonce_odr @_ZTV6Father = #cir.vtable<{#cir.const_array<[#cir.ptr<null> : !cir.ptr<!u8i>, #cir.global_view<@_ZTI6Father> : !cir.ptr<!u8i>, #cir.global_view<@_ZN6Father9FatherFooEv> : !cir.ptr<!u8i>]> : !cir.array<!cir.ptr<!u8i> x 3>}> : !ty_anon_struct3 {alignment = 8 : i64} 
-  cir.func linkonce_odr @_ZN6FatherC2Ev(%arg0: !cir.ptr<!ty_22Father22> ) { cir.return }
+  cir.func linkonce_odr @_ZN6FatherC2Ev(%arg0: !cir.ptr<!ty_Father> ) { cir.return }
   cir.global linkonce_odr @_ZTV5Child = #cir.vtable<{#cir.const_array<[#cir.ptr<null> : !cir.ptr<!u8i>, #cir.global_view<@_ZTI5Child> : !cir.ptr<!u8i>, #cir.global_view<@_ZN5Child9MotherFooEv> : !cir.ptr<!u8i>, #cir.global_view<@_ZN6Mother10MotherFoo2Ev> : !cir.ptr<!u8i>]> : !cir.array<!cir.ptr<!u8i> x 4>, #cir.const_array<[#cir.ptr<-8 : i64> : !cir.ptr<!u8i>, #cir.global_view<@_ZTI5Child> : !cir.ptr<!u8i>, #cir.global_view<@_ZN6Father9FatherFooEv> : !cir.ptr<!u8i>]> : !cir.array<!cir.ptr<!u8i> x 3>}> : !ty_anon_struct4 {alignment = 8 : i64} 
   cir.global "private" external @_ZTVN10__cxxabiv121__vmi_class_type_infoE : !cir.ptr<!cir.ptr<!u8i>> 
   cir.global linkonce_odr @_ZTS5Child = #cir.const_array<"5Child" : !cir.array<!s8i x 6>> : !cir.array<!s8i x 6> {alignment = 1 : i64} 
   cir.global linkonce_odr @_ZTS6Father = #cir.const_array<"6Father" : !cir.array<!s8i x 7>> : !cir.array<!s8i x 7> {alignment = 1 : i64} 
   cir.global constant external @_ZTI6Father = #cir.typeinfo<{#cir.global_view<@_ZTVN10__cxxabiv117__class_type_infoE, [2 : i32]> : !cir.ptr<!u8i>, #cir.global_view<@_ZTS6Father> : !cir.ptr<!u8i>}> : !ty_anon_struct {alignment = 8 : i64} 
   cir.global constant external @_ZTI5Child = #cir.typeinfo<{#cir.global_view<@_ZTVN10__cxxabiv121__vmi_class_type_infoE, [2 : i32]> : !cir.ptr<!u8i>, #cir.global_view<@_ZTS5Child> : !cir.ptr<!u8i>, #cir.int<0> : !u32i, #cir.int<2> : !u32i, #cir.global_view<@_ZTI6Mother> : !cir.ptr<!u8i>, #cir.int<2> : !s64i, #cir.global_view<@_ZTI6Father> : !cir.ptr<!u8i>, #cir.int<2050> : !s64i}> : !ty_anon_struct1 {alignment = 8 : i64} 
-  cir.func linkonce_odr @_ZN5Child9MotherFooEv(%arg0: !cir.ptr<!ty_22Child22> ) { cir.return }
-  cir.func linkonce_odr @_ZN6Father9FatherFooEv(%arg0: !cir.ptr<!ty_22Father22> ) { cir.return }
+  cir.func linkonce_odr @_ZN5Child9MotherFooEv(%arg0: !cir.ptr<!ty_Child> ) { cir.return }
+  cir.func linkonce_odr @_ZN6Father9FatherFooEv(%arg0: !cir.ptr<!ty_Father> ) { cir.return }
 } 
 
 // MLIR:  llvm.mlir.global linkonce_odr @_ZTV5Child() {addr_space = 0 : i32, alignment = 8 : i64} : !llvm.struct<(array<4 x ptr>, array<3 x ptr>)> {
diff --git a/clang/test/CIR/Lowering/array.cir b/clang/test/CIR/Lowering/array.cir
index 278225761d33..554a4a1fc18a 100644
--- a/clang/test/CIR/Lowering/array.cir
+++ b/clang/test/CIR/Lowering/array.cir
@@ -2,7 +2,7 @@
 // RUN: cir-translate %s -cir-to-llvmir -o -  | FileCheck %s -check-prefix=LLVM
 
 !s32i = !cir.int<s, 32>
-!ty_22S22 = !cir.struct<struct "S" {!s32i} #cir.record.decl.ast>
+!ty_S = !cir.struct<struct "S" {!s32i} #cir.record.decl.ast>
 
 module {
   cir.func @foo() {
@@ -21,7 +21,7 @@ module {
 //      LLVM: %1 = alloca [10 x i32], i64 1, align 16
 // LLVM-NEXT: ret void
 
-  cir.global external @arr = #cir.const_array<[#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_22S22, #cir.zero : !ty_22S22]> : !cir.array<!ty_22S22 x 2>
+  cir.global external @arr = #cir.const_array<[#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_S, #cir.zero : !ty_S]> : !cir.array<!ty_S x 2>
   // CHECK: llvm.mlir.global external @arr() {addr_space = 0 : i32} : !llvm.array<2 x struct<"struct.S", (i32)>> {
   // CHECK:   %0 = llvm.mlir.undef : !llvm.array<2 x struct<"struct.S", (i32)>>
   // CHECK:   %1 = llvm.mlir.undef : !llvm.struct<"struct.S", (i32)>
diff --git a/clang/test/CIR/Lowering/class.cir b/clang/test/CIR/Lowering/class.cir
index 03ef0568d1d1..dd028f4c3b7d 100644
--- a/clang/test/CIR/Lowering/class.cir
+++ b/clang/test/CIR/Lowering/class.cir
@@ -4,28 +4,28 @@
 !s32i = !cir.int<s, 32>
 !u8i = !cir.int<u, 8>
 !u32i = !cir.int<u, 32>
-!ty_22S22 = !cir.struct<class "S" {!u8i, !s32i}>
-!ty_22S2A22 = !cir.struct<class "S2A" {!s32i} #cir.record.decl.ast>
-!ty_22S122 = !cir.struct<class "S1" {!s32i, !cir.float, !cir.ptr<!s32i>} #cir.record.decl.ast>
-!ty_22S222 = !cir.struct<class "S2" {!ty_22S2A22} #cir.record.decl.ast>
-!ty_22S322 = !cir.struct<class "S3" {!s32i} #cir.record.decl.ast>
+!ty_S = !cir.struct<class "S" {!u8i, !s32i}>
+!ty_S2A = !cir.struct<class "S2A" {!s32i} #cir.record.decl.ast>
+!ty_S1_ = !cir.struct<class "S1" {!s32i, !cir.float, !cir.ptr<!s32i>} #cir.record.decl.ast>
+!ty_S2_ = !cir.struct<class "S2" {!ty_S2A} #cir.record.decl.ast>
+!ty_S3_ = !cir.struct<class "S3" {!s32i} #cir.record.decl.ast>
 
 module {
   cir.func @test() {
-    %1 = cir.alloca !ty_22S22, !cir.ptr<!ty_22S22>, ["x"] {alignment = 4 : i64}
+    %1 = cir.alloca !ty_S, !cir.ptr<!ty_S>, ["x"] {alignment = 4 : i64}
     // CHECK: %[[#ARRSIZE:]] = llvm.mlir.constant(1 : index) : i64
     // CHECK: %[[#CLASS:]] = llvm.alloca %[[#ARRSIZE]] x !llvm.struct<"class.S", (i8, i32)>
-    %3 = cir.get_member %1[0] {name = "c"} : !cir.ptr<!ty_22S22> -> !cir.ptr<!u8i>
+    %3 = cir.get_member %1[0] {name = "c"} : !cir.ptr<!ty_S> -> !cir.ptr<!u8i>
     // CHECK: = llvm.getelementptr %[[#CLASS]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.S", (i8, i32)>
-    %5 = cir.get_member %1[1] {name = "i"} : !cir.ptr<!ty_22S22> -> !cir.ptr<!s32i>
+    %5 = cir.get_member %1[1] {name = "i"} : !cir.ptr<!ty_S> -> !cir.ptr<!s32i>
     // CHECK: = llvm.getelementptr %[[#CLASS]][0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.S", (i8, i32)>
     cir.return
   }
 
   cir.func @shouldConstInitLocalClassesWithConstStructAttr() {
-    %0 = cir.alloca !ty_22S2A22, !cir.ptr<!ty_22S2A22>, ["s"] {alignment = 4 : i64}
-    %1 = cir.const #cir.const_struct<{#cir.int<1> : !s32i}> : !ty_22S2A22
-    cir.store %1, %0 : !ty_22S2A22, !cir.ptr<!ty_22S2A22>
+    %0 = cir.alloca !ty_S2A, !cir.ptr<!ty_S2A>, ["s"] {alignment = 4 : i64}
+    %1 = cir.const #cir.const_struct<{#cir.int<1> : !s32i}> : !ty_S2A
+    cir.store %1, %0 : !ty_S2A, !cir.ptr<!ty_S2A>
     cir.return
   }
   // CHECK: llvm.func @shouldConstInitLocalClassesWithConstStructAttr()
@@ -39,7 +39,7 @@ module {
   // CHECK: }
 
   // Should lower basic #cir.const_struct initializer.
-  cir.global external @s1 = #cir.const_struct<{#cir.int<1> : !s32i, #cir.fp<1.000000e-01> : !cir.float, #cir.ptr<null> : !cir.ptr<!s32i>}> : !ty_22S122
+  cir.global external @s1 = #cir.const_struct<{#cir.int<1> : !s32i, #cir.fp<1.000000e-01> : !cir.float, #cir.ptr<null> : !cir.ptr<!s32i>}> : !ty_S1_
   // CHECK: llvm.mlir.global external @s1() {addr_space = 0 : i32} : !llvm.struct<"class.S1", (i32, f32, ptr)> {
   // CHECK:   %0 = llvm.mlir.undef : !llvm.struct<"class.S1", (i32, f32, ptr)>
   // CHECK:   %1 = llvm.mlir.constant(1 : i32) : i32
@@ -52,7 +52,7 @@ module {
   // CHECK: }
 
   // Should lower nested #cir.const_struct initializer.
-  cir.global external @s2 = #cir.const_struct<{#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_22S2A22}> : !ty_22S222
+  cir.global external @s2 = #cir.const_struct<{#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_S2A}> : !ty_S2_
   // CHECK: llvm.mlir.global external @s2() {addr_space = 0 : i32} : !llvm.struct<"class.S2", (struct<"class.S2A", (i32)>)> {
   // CHECK:   %0 = llvm.mlir.undef : !llvm.struct<"class.S2", (struct<"class.S2A", (i32)>)>
   // CHECK:   %1 = llvm.mlir.undef : !llvm.struct<"class.S2A", (i32)>
@@ -62,7 +62,7 @@ module {
   // CHECK:   llvm.return %4 : !llvm.struct<"class.S2", (struct<"class.S2A", (i32)>)>
   // CHECK: }
 
-  cir.global external @s3 = #cir.const_array<[#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_22S322, #cir.const_struct<{#cir.int<2> : !s32i}> : !ty_22S322, #cir.const_struct<{#cir.int<3> : !s32i}> : !ty_22S322]> : !cir.array<!ty_22S322 x 3>
+  cir.global external @s3 = #cir.const_array<[#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_S3_, #cir.const_struct<{#cir.int<2> : !s32i}> : !ty_S3_, #cir.const_struct<{#cir.int<3> : !s32i}> : !ty_S3_]> : !cir.array<!ty_S3_ x 3>
   // CHECK: llvm.mlir.global external @s3() {addr_space = 0 : i32} : !llvm.array<3 x struct<"class.S3", (i32)>> {
   // CHECK:   %0 = llvm.mlir.undef : !llvm.array<3 x struct<"class.S3", (i32)>>
   // CHECK:   %1 = llvm.mlir.undef : !llvm.struct<"class.S3", (i32)>
@@ -82,13 +82,13 @@ module {
 
   cir.func @shouldLowerClassCopies() {
   // CHECK: llvm.func @shouldLowerClassCopies()
-    %1 = cir.alloca !ty_22S22, !cir.ptr<!ty_22S22>, ["a"] {alignment = 4 : i64}
+    %1 = cir.alloca !ty_S, !cir.ptr<!ty_S>, ["a"] {alignment = 4 : i64}
     // CHECK: %[[#ONE:]] = llvm.mlir.constant(1 : index) : i64
     // CHECK: %[[#SA:]] = llvm.alloca %[[#ONE]] x !llvm.struct<"class.S", (i8, i32)> {alignment = 4 : i64} : (i64) -> !llvm.ptr
-    %2 = cir.alloca !ty_22S22, !cir.ptr<!ty_22S22>, ["b", init] {alignment = 4 : i64}
+    %2 = cir.alloca !ty_S, !cir.ptr<!ty_S>, ["b", init] {alignment = 4 : i64}
     // CHECK: %[[#ONE:]] = llvm.mlir.constant(1 : index) : i64
     // CHECK: %[[#SB:]] = llvm.alloca %[[#ONE]] x !llvm.struct<"class.S", (i8, i32)> {alignment = 4 : i64} : (i64) -> !llvm.ptr
-    cir.copy %1 to %2 : !cir.ptr<!ty_22S22>
+    cir.copy %1 to %2 : !cir.ptr<!ty_S>
     // CHECK: %[[#SIZE:]] = llvm.mlir.constant(8 : i32) : i32
     // CHECK: "llvm.intr.memcpy"(%[[#SB]], %[[#SA]], %[[#SIZE]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()
     cir.return
diff --git a/clang/test/CIR/Lowering/const.cir b/clang/test/CIR/Lowering/const.cir
index 764089c1d6cb..4bb234c56995 100644
--- a/clang/test/CIR/Lowering/const.cir
+++ b/clang/test/CIR/Lowering/const.cir
@@ -4,7 +4,7 @@
 !s8i = !cir.int<s, 8>
 !s32i = !cir.int<s, 32>
 !s64i = !cir.int<s, 64>
-!ty_22anon2E122 = !cir.struct<struct "anon.1" {!cir.int<s, 32>, !cir.int<s, 32>} #cir.record.decl.ast>
+!ty_anon2E1_ = !cir.struct<struct "anon.1" {!cir.int<s, 32>, !cir.int<s, 32>} #cir.record.decl.ast>
 module {
   cir.func @testConstArrInit() {
     %0 = cir.const #cir.const_array<"string\00" : !cir.array<!s8i x 7>> : !cir.array<!s8i x 7>
@@ -36,9 +36,9 @@ module {
   // CHECK:    llvm.return
 
   cir.func @testConstArrayOfStructs() {
-    %0 = cir.alloca !cir.array<!ty_22anon2E122 x 1>, !cir.ptr<!cir.array<!ty_22anon2E122 x 1>>, ["a"] {alignment = 4 : i64}
-    %1 = cir.const #cir.const_array<[#cir.const_struct<{#cir.int<0> : !s32i, #cir.int<1> : !s32i}> : !ty_22anon2E122]> : !cir.array<!ty_22anon2E122 x 1>
-    cir.store %1, %0 : !cir.array<!ty_22anon2E122 x 1>, !cir.ptr<!cir.array<!ty_22anon2E122 x 1>>
+    %0 = cir.alloca !cir.array<!ty_anon2E1_ x 1>, !cir.ptr<!cir.array<!ty_anon2E1_ x 1>>, ["a"] {alignment = 4 : i64}
+    %1 = cir.const #cir.const_array<[#cir.const_struct<{#cir.int<0> : !s32i, #cir.int<1> : !s32i}> : !ty_anon2E1_]> : !cir.array<!ty_anon2E1_ x 1>
+    cir.store %1, %0 : !cir.array<!ty_anon2E1_ x 1>, !cir.ptr<!cir.array<!ty_anon2E1_ x 1>>
     cir.return
   }
   // CHECK:  llvm.func @testConstArrayOfStructs()
diff --git a/clang/test/CIR/Lowering/globals.cir b/clang/test/CIR/Lowering/globals.cir
index 164411ee899f..c3bd1cc3a726 100644
--- a/clang/test/CIR/Lowering/globals.cir
+++ b/clang/test/CIR/Lowering/globals.cir
@@ -11,11 +11,11 @@
 !u32i = !cir.int<u, 32>
 !u64i = !cir.int<u, 64>
 !u8i = !cir.int<u, 8>
-!ty_22A22 = !cir.struct<struct "A" {!s32i, !cir.array<!cir.array<!s32i x 2> x 2>} #cir.record.decl.ast>
-!ty_22Bar22 = !cir.struct<struct "Bar" {!s32i, !s8i} #cir.record.decl.ast>
-!ty_22StringStruct22 = !cir.struct<struct "StringStruct" {!cir.array<!s8i x 3>, !cir.array<!s8i x 3>, !cir.array<!s8i x 3>} #cir.record.decl.ast>
-!ty_22StringStructPtr22 = !cir.struct<struct "StringStructPtr" {!cir.ptr<!s8i>} #cir.record.decl.ast>
-!ty_22anon2E122 = !cir.struct<struct "anon.1" {!cir.ptr<!cir.func<!cir.void (!cir.int<s, 32>)>>} #cir.record.decl.ast>
+!ty_A = !cir.struct<struct "A" {!s32i, !cir.array<!cir.array<!s32i x 2> x 2>} #cir.record.decl.ast>
+!ty_Bar = !cir.struct<struct "Bar" {!s32i, !s8i} #cir.record.decl.ast>
+!ty_StringStruct = !cir.struct<struct "StringStruct" {!cir.array<!s8i x 3>, !cir.array<!s8i x 3>, !cir.array<!s8i x 3>} #cir.record.decl.ast>
+!ty_StringStructPtr = !cir.struct<struct "StringStructPtr" {!cir.ptr<!s8i>} #cir.record.decl.ast>
+!ty_anon2E1_ = !cir.struct<struct "anon.1" {!cir.ptr<!cir.func<!cir.void (!cir.int<s, 32>)>>} #cir.record.decl.ast>
 
 module {
   cir.global external @a = #cir.int<3> : !s32i
@@ -91,11 +91,11 @@ module {
 
   // The following tests check direclty the resulting LLVM IR because the MLIR
   // version is two long. Always prefer the MLIR prefix when possible.
-  cir.global external @nestedTwoDim = #cir.const_struct<{#cir.int<1> : !s32i, #cir.const_array<[#cir.const_array<[#cir.int<2> : !s32i, #cir.int<3> : !s32i]> : !cir.array<!s32i x 2>, #cir.const_array<[#cir.int<4> : !s32i, #cir.int<5> : !s32i]> : !cir.array<!s32i x 2>]> : !cir.array<!cir.array<!s32i x 2> x 2>}> : !ty_22A22
+  cir.global external @nestedTwoDim = #cir.const_struct<{#cir.int<1> : !s32i, #cir.const_array<[#cir.const_array<[#cir.int<2> : !s32i, #cir.int<3> : !s32i]> : !cir.array<!s32i x 2>, #cir.const_array<[#cir.int<4> : !s32i, #cir.int<5> : !s32i]> : !cir.array<!s32i x 2>]> : !cir.array<!cir.array<!s32i x 2> x 2>}> : !ty_A
   // LLVM: @nestedTwoDim = global %struct.A { i32 1, [2 x [2 x i32{{\]\] \[\[}}2 x i32] [i32 2, i32 3], [2 x i32] [i32 4, i32 5{{\]\]}} }
-  cir.global external @nestedString = #cir.const_struct<{#cir.const_array<"1\00\00" : !cir.array<!s8i x 3>> : !cir.array<!s8i x 3>, #cir.const_array<"\00\00\00" : !cir.array<!s8i x 3>> : !cir.array<!s8i x 3>, #cir.const_array<"\00\00\00" : !cir.array<!s8i x 3>> : !cir.array<!s8i x 3>}> : !ty_22StringStruct22
+  cir.global external @nestedString = #cir.const_struct<{#cir.const_array<"1\00\00" : !cir.array<!s8i x 3>> : !cir.array<!s8i x 3>, #cir.const_array<"\00\00\00" : !cir.array<!s8i x 3>> : !cir.array<!s8i x 3>, #cir.const_array<"\00\00\00" : !cir.array<!s8i x 3>> : !cir.array<!s8i x 3>}> : !ty_StringStruct
   // LLVM: @nestedString = global %struct.StringStruct { [3 x i8] c"1\00\00", [3 x i8] zeroinitializer, [3 x i8] zeroinitializer }
-  cir.global external @nestedStringPtr = #cir.const_struct<{#cir.global_view<@".str"> : !cir.ptr<!s8i>}> : !ty_22StringStructPtr22
+  cir.global external @nestedStringPtr = #cir.const_struct<{#cir.global_view<@".str"> : !cir.ptr<!s8i>}> : !ty_StringStructPtr
   // LLVM: @nestedStringPtr = global %struct.StringStructPtr { ptr @.str }
 
   cir.func @_Z11get_globalsv() {
@@ -142,7 +142,7 @@ module {
   // MLIR:   %0 = llvm.mlir.zero : !llvm.ptr
   // MLIR:   llvm.return %0 : !llvm.ptr
   // MLIR: }
-  cir.global external @zeroStruct = #cir.zero : !ty_22Bar22
+  cir.global external @zeroStruct = #cir.zero : !ty_Bar
   // MLIR: llvm.mlir.global external @zeroStruct()
   // MLIR:   %0 = llvm.mlir.zero : !llvm.struct<"struct.Bar", (i32, i8)>
   // MLIR:   llvm.return %0 : !llvm.struct<"struct.Bar", (i32, i8)>
@@ -150,7 +150,7 @@ module {
   cir.global common @comm = #cir.int<0> : !s32i
   // MLIR: llvm.mlir.global common @comm(0 : i32) {addr_space = 0 : i32} : i32
 
-  cir.global "private" internal @Handlers = #cir.const_array<[#cir.const_struct<{#cir.global_view<@myfun> : !cir.ptr<!cir.func<!void (!s32i)>>}> : !ty_22anon2E122]> : !cir.array<!ty_22anon2E122 x 1>
+  cir.global "private" internal @Handlers = #cir.const_array<[#cir.const_struct<{#cir.global_view<@myfun> : !cir.ptr<!cir.func<!void (!s32i)>>}> : !ty_anon2E1_]> : !cir.array<!ty_anon2E1_ x 1>
   cir.func internal private @myfun(%arg0: !s32i) {
     %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
     cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
@@ -161,11 +161,11 @@ module {
     %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["flag", init] {alignment = 4 : i64}
     cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
     cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
-    %2 = cir.get_global @Handlers : !cir.ptr<!cir.array<!ty_22anon2E122 x 1>>
+    %2 = cir.get_global @Handlers : !cir.ptr<!cir.array<!ty_anon2E1_ x 1>>
     %3 = cir.load %0 : !cir.ptr<!s32i>, !s32i
-    %4 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr<!cir.array<!ty_22anon2E122 x 1>>), !cir.ptr<!ty_22anon2E122>
-    %5 = cir.ptr_stride(%4 : !cir.ptr<!ty_22anon2E122>, %3 : !s32i), !cir.ptr<!ty_22anon2E122>
-    %6 = cir.get_member %5[0] {name = "func"} : !cir.ptr<!ty_22anon2E122> -> !cir.ptr<!cir.ptr<!cir.func<!void (!s32i)>>>
+    %4 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr<!cir.array<!ty_anon2E1_ x 1>>), !cir.ptr<!ty_anon2E1_>
+    %5 = cir.ptr_stride(%4 : !cir.ptr<!ty_anon2E1_>, %3 : !s32i), !cir.ptr<!ty_anon2E1_>
+    %6 = cir.get_member %5[0] {name = "func"} : !cir.ptr<!ty_anon2E1_> -> !cir.ptr<!cir.ptr<!cir.func<!void (!s32i)>>>
     %7 = cir.load %6 : !cir.ptr<!cir.ptr<!cir.func<!void (!s32i)>>>, !cir.ptr<!cir.func<!void (!s32i)>>
     %8 = cir.load %1 : !cir.ptr<!s32i>, !s32i
     cir.call %7(%8) : (!cir.ptr<!cir.func<!void (!s32i)>>, !s32i) -> ()
diff --git a/clang/test/CIR/Lowering/struct.cir b/clang/test/CIR/Lowering/struct.cir
index 7ae152e52713..a1a3d352c8a1 100644
--- a/clang/test/CIR/Lowering/struct.cir
+++ b/clang/test/CIR/Lowering/struct.cir
@@ -4,28 +4,28 @@
 !s32i = !cir.int<s, 32>
 !u8i = !cir.int<u, 8>
 !u32i = !cir.int<u, 32>
-!ty_22S22 = !cir.struct<struct "S" {!u8i, !s32i}>
-!ty_22S2A22 = !cir.struct<struct "S2A" {!s32i} #cir.record.decl.ast>
-!ty_22S122 = !cir.struct<struct "S1" {!s32i, !cir.float, !cir.ptr<!s32i>} #cir.record.decl.ast>
-!ty_22S222 = !cir.struct<struct "S2" {!ty_22S2A22} #cir.record.decl.ast>
-!ty_22S322 = !cir.struct<struct "S3" {!s32i} #cir.record.decl.ast>
+!ty_S = !cir.struct<struct "S" {!u8i, !s32i}>
+!ty_S2A = !cir.struct<struct "S2A" {!s32i} #cir.record.decl.ast>
+!ty_S1_ = !cir.struct<struct "S1" {!s32i, !cir.float, !cir.ptr<!s32i>} #cir.record.decl.ast>
+!ty_S2_ = !cir.struct<struct "S2" {!ty_S2A} #cir.record.decl.ast>
+!ty_S3_ = !cir.struct<struct "S3" {!s32i} #cir.record.decl.ast>
 
 module {
   cir.func @test() {
-    %1 = cir.alloca !ty_22S22, !cir.ptr<!ty_22S22>, ["x"] {alignment = 4 : i64}
+    %1 = cir.alloca !ty_S, !cir.ptr<!ty_S>, ["x"] {alignment = 4 : i64}
     // CHECK: %[[#ARRSIZE:]] = llvm.mlir.constant(1 : index) : i64
     // CHECK: %[[#STRUCT:]] = llvm.alloca %[[#ARRSIZE]] x !llvm.struct<"struct.S", (i8, i32)>
-    %3 = cir.get_member %1[0] {name = "c"} : !cir.ptr<!ty_22S22> -> !cir.ptr<!u8i>
+    %3 = cir.get_member %1[0] {name = "c"} : !cir.ptr<!ty_S> -> !cir.ptr<!u8i>
     // CHECK: = llvm.getelementptr %[[#STRUCT]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"struct.S", (i8, i32)>
-    %5 = cir.get_member %1[1] {name = "i"} : !cir.ptr<!ty_22S22> -> !cir.ptr<!s32i>
+    %5 = cir.get_member %1[1] {name = "i"} : !cir.ptr<!ty_S> -> !cir.ptr<!s32i>
     // CHECK: = llvm.getelementptr %[[#STRUCT]][0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"struct.S", (i8, i32)>
     cir.return
   }
 
   cir.func @shouldConstInitLocalStructsWithConstStructAttr() {
-    %0 = cir.alloca !ty_22S2A22, !cir.ptr<!ty_22S2A22>, ["s"] {alignment = 4 : i64}
-    %1 = cir.const #cir.const_struct<{#cir.int<1> : !s32i}> : !ty_22S2A22
-    cir.store %1, %0 : !ty_22S2A22, !cir.ptr<!ty_22S2A22>
+    %0 = cir.alloca !ty_S2A, !cir.ptr<!ty_S2A>, ["s"] {alignment = 4 : i64}
+    %1 = cir.const #cir.const_struct<{#cir.int<1> : !s32i}> : !ty_S2A
+    cir.store %1, %0 : !ty_S2A, !cir.ptr<!ty_S2A>
     cir.return
   }
   // CHECK: llvm.func @shouldConstInitLocalStructsWithConstStructAttr()
@@ -39,7 +39,7 @@ module {
   // CHECK: }
 
   // Should lower basic #cir.const_struct initializer.
-  cir.global external @s1 = #cir.const_struct<{#cir.int<1> : !s32i, #cir.fp<1.000000e-01> : !cir.float, #cir.ptr<null> : !cir.ptr<!s32i>}> : !ty_22S122
+  cir.global external @s1 = #cir.const_struct<{#cir.int<1> : !s32i, #cir.fp<1.000000e-01> : !cir.float, #cir.ptr<null> : !cir.ptr<!s32i>}> : !ty_S1_
   // CHECK: llvm.mlir.global external @s1() {addr_space = 0 : i32} : !llvm.struct<"struct.S1", (i32, f32, ptr)> {
   // CHECK:   %0 = llvm.mlir.undef : !llvm.struct<"struct.S1", (i32, f32, ptr)>
   // CHECK:   %1 = llvm.mlir.constant(1 : i32) : i32
@@ -52,7 +52,7 @@ module {
   // CHECK: }
 
   // Should lower nested #cir.const_struct initializer.
-  cir.global external @s2 = #cir.const_struct<{#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_22S2A22}> : !ty_22S222
+  cir.global external @s2 = #cir.const_struct<{#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_S2A}> : !ty_S2_
   // CHECK: llvm.mlir.global external @s2() {addr_space = 0 : i32} : !llvm.struct<"struct.S2", (struct<"struct.S2A", (i32)>)> {
   // CHECK:   %0 = llvm.mlir.undef : !llvm.struct<"struct.S2", (struct<"struct.S2A", (i32)>)>
   // CHECK:   %1 = llvm.mlir.undef : !llvm.struct<"struct.S2A", (i32)>
@@ -62,7 +62,7 @@ module {
   // CHECK:   llvm.return %4 : !llvm.struct<"struct.S2", (struct<"struct.S2A", (i32)>)>
   // CHECK: }
 
-  cir.global external @s3 = #cir.const_array<[#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_22S322, #cir.const_struct<{#cir.int<2> : !s32i}> : !ty_22S322, #cir.const_struct<{#cir.int<3> : !s32i}> : !ty_22S322]> : !cir.array<!ty_22S322 x 3>
+  cir.global external @s3 = #cir.const_array<[#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_S3_, #cir.const_struct<{#cir.int<2> : !s32i}> : !ty_S3_, #cir.const_struct<{#cir.int<3> : !s32i}> : !ty_S3_]> : !cir.array<!ty_S3_ x 3>
   // CHECK: llvm.mlir.global external @s3() {addr_space = 0 : i32} : !llvm.array<3 x struct<"struct.S3", (i32)>> {
   // CHECK:   %0 = llvm.mlir.undef : !llvm.array<3 x struct<"struct.S3", (i32)>>
   // CHECK:   %1 = llvm.mlir.undef : !llvm.struct<"struct.S3", (i32)>
@@ -82,13 +82,13 @@ module {
 
   cir.func @shouldLowerStructCopies() {
   // CHECK: llvm.func @shouldLowerStructCopies()
-    %1 = cir.alloca !ty_22S22, !cir.ptr<!ty_22S22>, ["a"] {alignment = 4 : i64}
+    %1 = cir.alloca !ty_S, !cir.ptr<!ty_S>, ["a"] {alignment = 4 : i64}
     // CHECK: %[[#ONE:]] = llvm.mlir.constant(1 : index) : i64
     // CHECK: %[[#SA:]] = llvm.alloca %[[#ONE]] x !llvm.struct<"struct.S", (i8, i32)> {alignment = 4 : i64} : (i64) -> !llvm.ptr
-    %2 = cir.alloca !ty_22S22, !cir.ptr<!ty_22S22>, ["b", init] {alignment = 4 : i64}
+    %2 = cir.alloca !ty_S, !cir.ptr<!ty_S>, ["b", init] {alignment = 4 : i64}
     // CHECK: %[[#ONE:]] = llvm.mlir.constant(1 : index) : i64
     // CHECK: %[[#SB:]] = llvm.alloca %[[#ONE]] x !llvm.struct<"struct.S", (i8, i32)> {alignment = 4 : i64} : (i64) -> !llvm.ptr
-    cir.copy %1 to %2 : !cir.ptr<!ty_22S22>
+    cir.copy %1 to %2 : !cir.ptr<!ty_S>
     // CHECK: %[[#SIZE:]] = llvm.mlir.constant(8 : i32) : i32
     // CHECK: "llvm.intr.memcpy"(%[[#SB]], %[[#SA]], %[[#SIZE]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()
     cir.return
diff --git a/clang/test/CIR/Lowering/unions.cir b/clang/test/CIR/Lowering/unions.cir
index 6fbcd89b9a97..0cc9d1d15749 100644
--- a/clang/test/CIR/Lowering/unions.cir
+++ b/clang/test/CIR/Lowering/unions.cir
@@ -4,26 +4,26 @@
 !s16i = !cir.int<s, 16>
 !s32i = !cir.int<s, 32>
 #true = #cir.bool<true> : !cir.bool
-!ty_22U122 = !cir.struct<union "U1" {!cir.bool, !s16i, !s32i} #cir.record.decl.ast>
-!ty_22U222 = !cir.struct<union "U2" {f64, !ty_22U122} #cir.record.decl.ast>
-!ty_22U322 = !cir.struct<union "U3" {!s16i, !ty_22U122} #cir.record.decl.ast>
+!ty_U1_ = !cir.struct<union "U1" {!cir.bool, !s16i, !s32i} #cir.record.decl.ast>
+!ty_U2_ = !cir.struct<union "U2" {f64, !ty_U1_} #cir.record.decl.ast>
+!ty_U3_ = !cir.struct<union "U3" {!s16i, !ty_U1_} #cir.record.decl.ast>
 module {
   // Should lower union to struct with only the largest member.
-  cir.global external @u1 = #cir.zero : !ty_22U122
+  cir.global external @u1 = #cir.zero : !ty_U1_
   // CHECK: llvm.mlir.global external @u1() {addr_space = 0 : i32} : !llvm.struct<"union.U1", (i32)>
 
   // Should recursively find the largest member if there are nested unions.
-  cir.global external @u2 = #cir.zero : !ty_22U222
-  cir.global external @u3 = #cir.zero : !ty_22U322
+  cir.global external @u2 = #cir.zero : !ty_U2_
+  cir.global external @u3 = #cir.zero : !ty_U3_
   // CHECK: llvm.mlir.global external @u2() {addr_space = 0 : i32} : !llvm.struct<"union.U2", (f64)>
   // CHECK: llvm.mlir.global external @u3() {addr_space = 0 : i32} : !llvm.struct<"union.U3", (i32)>
 
   // CHECK: llvm.func @test
-  cir.func @test(%arg0: !cir.ptr<!ty_22U122>) {
+  cir.func @test(%arg0: !cir.ptr<!ty_U1_>) {
 
     // Should store directly to the union's base address.
     %5 = cir.const #true
-    %6 = cir.get_member %arg0[0] {name = "b"} : !cir.ptr<!ty_22U122> -> !cir.ptr<!cir.bool>
+    %6 = cir.get_member %arg0[0] {name = "b"} : !cir.ptr<!ty_U1_> -> !cir.ptr<!cir.bool>
     cir.store %5, %6 : !cir.bool, !cir.ptr<!cir.bool>
     // CHECK: %[[#VAL:]] = llvm.mlir.constant(1 : i8) : i8
     // The bitcast it just to bypass the type checker. It will be replaced by an opaque pointer.
@@ -31,7 +31,7 @@ module {
     // CHECK: llvm.store %[[#VAL]], %[[#ADDR]] {{.*}}: i8, !llvm.ptr
 
     // Should load direclty from the union's base address.
-    %7 = cir.get_member %arg0[0] {name = "b"} : !cir.ptr<!ty_22U122> -> !cir.ptr<!cir.bool>
+    %7 = cir.get_member %arg0[0] {name = "b"} : !cir.ptr<!ty_U1_> -> !cir.ptr<!cir.bool>
     %8 = cir.load %7 : !cir.ptr<!cir.bool>, !cir.bool
     // The bitcast it just to bypass the type checker. It will be replaced by an opaque pointer.
     // CHECK: %[[#BASE:]] = llvm.bitcast %{{.+}} : !llvm.ptr
diff --git a/clang/test/CIR/Lowering/variadics.cir b/clang/test/CIR/Lowering/variadics.cir
index b4a5a30c5e82..dfbfbf66e56f 100644
--- a/clang/test/CIR/Lowering/variadics.cir
+++ b/clang/test/CIR/Lowering/variadics.cir
@@ -5,30 +5,30 @@
 !u32i = !cir.int<u, 32>
 !u8i = !cir.int<u, 8>
 
-!ty_22__va_list_tag22 = !cir.struct<struct "__va_list_tag" {!u32i, !u32i, !cir.ptr<!u8i>, !cir.ptr<!u8i>} #cir.record.decl.ast>
+!ty___va_list_tag = !cir.struct<struct "__va_list_tag" {!u32i, !u32i, !cir.ptr<!u8i>, !cir.ptr<!u8i>} #cir.record.decl.ast>
 
 module {
   cir.func @average(%arg0: !s32i, ...) -> !s32i {
     %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["count", init] {alignment = 4 : i64}
     %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
-    %2 = cir.alloca !cir.array<!ty_22__va_list_tag22 x 1>, !cir.ptr<!cir.array<!ty_22__va_list_tag22 x 1>>, ["args"] {alignment = 16 : i64}
-    %3 = cir.alloca !cir.array<!ty_22__va_list_tag22 x 1>, !cir.ptr<!cir.array<!ty_22__va_list_tag22 x 1>>, ["args_copy"] {alignment = 16 : i64}
+    %2 = cir.alloca !cir.array<!ty___va_list_tag x 1>, !cir.ptr<!cir.array<!ty___va_list_tag x 1>>, ["args"] {alignment = 16 : i64}
+    %3 = cir.alloca !cir.array<!ty___va_list_tag x 1>, !cir.ptr<!cir.array<!ty___va_list_tag x 1>>, ["args_copy"] {alignment = 16 : i64}
     cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
-    %4 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr<!cir.array<!ty_22__va_list_tag22 x 1>>), !cir.ptr<!ty_22__va_list_tag22>
-    cir.va.start %4 : !cir.ptr<!ty_22__va_list_tag22>
+    %4 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr<!cir.array<!ty___va_list_tag x 1>>), !cir.ptr<!ty___va_list_tag>
+    cir.va.start %4 : !cir.ptr<!ty___va_list_tag>
     //      MLIR: %{{[0-9]+}} = llvm.getelementptr %{{[0-9]+}}[0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"struct.__va_list_tag", (i32, i32, ptr, ptr)>
     // MLIR-NEXT: %{{[0-9]+}} = llvm.bitcast %{{[0-9]+}} : !llvm.ptr to !llvm.ptr
     // MLIR-NEXT: llvm.intr.vastart %{{[0-9]+}} : !llvm.ptr
-    %5 = cir.cast(array_to_ptrdecay, %3 : !cir.ptr<!cir.array<!ty_22__va_list_tag22 x 1>>), !cir.ptr<!ty_22__va_list_tag22>
-    %6 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr<!cir.array<!ty_22__va_list_tag22 x 1>>), !cir.ptr<!ty_22__va_list_tag22>
-    cir.va.copy %6 to %5 : !cir.ptr<!ty_22__va_list_tag22>, !cir.ptr<!ty_22__va_list_tag22>
+    %5 = cir.cast(array_to_ptrdecay, %3 : !cir.ptr<!cir.array<!ty___va_list_tag x 1>>), !cir.ptr<!ty___va_list_tag>
+    %6 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr<!cir.array<!ty___va_list_tag x 1>>), !cir.ptr<!ty___va_list_tag>
+    cir.va.copy %6 to %5 : !cir.ptr<!ty___va_list_tag>, !cir.ptr<!ty___va_list_tag>
     //      MLIR: %{{[0-9]+}} = llvm.getelementptr %{{[0-9]+}}[0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"struct.__va_list_tag", (i32, i32, ptr, ptr)>
     // MLIR-NEXT: %{{[0-9]+}} = llvm.getelementptr %{{[0-9]+}}[0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"struct.__va_list_tag", (i32, i32, ptr, ptr)>
     // MLIR-NEXT: %{{[0-9]+}} = llvm.bitcast %{{[0-9]+}} : !llvm.ptr to !llvm.ptr
     // MLIR-NEXT: %{{[0-9]+}} = llvm.bitcast %{{[0-9]+}} : !llvm.ptr to !llvm.ptr
     // MLIR-NEXT: llvm.intr.vacopy %13 to %{{[0-9]+}} : !llvm.ptr, !llvm.ptr
-    %7 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr<!cir.array<!ty_22__va_list_tag22 x 1>>), !cir.ptr<!ty_22__va_list_tag22>
-    cir.va.end %7 : !cir.ptr<!ty_22__va_list_tag22>
+    %7 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr<!cir.array<!ty___va_list_tag x 1>>), !cir.ptr<!ty___va_list_tag>
+    cir.va.end %7 : !cir.ptr<!ty___va_list_tag>
     //      MLIR: %{{[0-9]+}} = llvm.getelementptr %{{[0-9]+}}[0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"struct.__va_list_tag", (i32, i32, ptr, ptr)>
     // MLIR-NEXT: %{{[0-9]+}} = llvm.bitcast %{{[0-9]+}} : !llvm.ptr to !llvm.ptr
     // MLIR-NEXT: llvm.intr.vaend %{{[0-9]+}} : !llvm.ptr
diff --git a/clang/test/CIR/Transforms/Target/x86_64/x86_64-call-conv-lowering-pass.cpp b/clang/test/CIR/Transforms/Target/x86_64/x86_64-call-conv-lowering-pass.cpp
index 48345dfc7c0d..3789550ce33b 100644
--- a/clang/test/CIR/Transforms/Target/x86_64/x86_64-call-conv-lowering-pass.cpp
+++ b/clang/test/CIR/Transforms/Target/x86_64/x86_64-call-conv-lowering-pass.cpp
@@ -100,19 +100,19 @@ struct S1 {
 
 /// Cast arguments to the expected type.
 // CHECK: cir.func @_Z2s12S1(%arg0: !u64i loc({{.+}})) -> !u64i
-// CHECK: %[[#V0:]] = cir.alloca !ty_22S122, !cir.ptr<!ty_22S122>
-// CHECK: %[[#V1:]] = cir.cast(bitcast, %arg0 : !u64i), !ty_22S122
-// CHECK: cir.store %[[#V1]], %[[#V0]] : !ty_22S122, !cir.ptr<!ty_22S122>
+// CHECK: %[[#V0:]] = cir.alloca !ty_S1_, !cir.ptr<!ty_S1_>
+// CHECK: %[[#V1:]] = cir.cast(bitcast, %arg0 : !u64i), !ty_S1_
+// CHECK: cir.store %[[#V1]], %[[#V0]] : !ty_S1_, !cir.ptr<!ty_S1_>
 S1 s1(S1 arg) {
 
   /// Cast argument and result of the function call to the expected types.
-  // CHECK: %[[#V9:]] = cir.cast(bitcast, %{{.+}} : !ty_22S122), !u64i
+  // CHECK: %[[#V9:]] = cir.cast(bitcast, %{{.+}} : !ty_S1_), !u64i
   // CHECK: %[[#V10:]] = cir.call @_Z2s12S1(%[[#V9]]) : (!u64i) -> !u64i
-  // CHECK: %[[#V11:]] = cir.cast(bitcast, %[[#V10]] : !u64i), !ty_22S122
+  // CHECK: %[[#V11:]] = cir.cast(bitcast, %[[#V10]] : !u64i), !ty_S1_
   s1({1, 2});
 
-  // CHECK: %[[#V12:]] = cir.load %{{.+}} : !cir.ptr<!ty_22S122>, !ty_22S122
-  // CHECK: %[[#V13:]] = cir.cast(bitcast, %[[#V12]] : !ty_22S122), !u64i
+  // CHECK: %[[#V12:]] = cir.load %{{.+}} : !cir.ptr<!ty_S1_>, !ty_S1_
+  // CHECK: %[[#V13:]] = cir.cast(bitcast, %[[#V12]] : !ty_S1_), !u64i
   // CHECK: cir.return %[[#V13]] : !u64i
   return {1, 2};
 }