[ARM64EC 12/?] Add param/ret attr for struct to help generate correct thunk for arm64ec

[bcl5980]

Summary

When we compile a function on Arm64EC, the function need arm64 function signature, and a corresponding x64 signature.
The frontend always generates the function with the arm64 signature, and thunk generation translates that to the x64 signature.
For now only from arm64 signature function type we can't translate all kinds of function to x64 signature.
So this change add a attribute to contain structure's original size to help thunk generation pass to generate correct x64 signature.

[bcl5980]

rebase

[bcl5980]

add getParamArm64ECArgX86SignBytes into function.h

[efriedma]

Using "Sign" as an abbreviation for "Signature" is confusing. Avoid abbreviating if you can; if you think it's necessary, use "Sig" as shorthand for "Signature".

Not sure it's the right thing to put in the name of the attribute, though; the name of the attribute should probably mention it's the "size" of the argument. Maybe just arm64ec_arg_size().

---

This looks like it matches the approach I suggested.

clang/lib/CodeGen/CGCall.cpp

2338

Ty->isArrayType() will never be true; type promotion rules don't allow specifying an array as a function argument.

2340

Please use getTypeSizeInChars().

[bcl5980]

Rename the attribute to arm64ecargsize

clang/lib/CodeGen/CGCall.cpp

void CodeGenModule::ConstructAttributeList(StringRef Name,
 
   // Determine if the return type could be partially undef
   if (CodeGenOpts.EnableNoundefAttrs && HasStrictReturn) {
     if (!RetTy->isVoidType() && RetAI.getKind() != ABIArgInfo::Indirect &&
         DetermineNoUndef(RetTy, getTypes(), DL, RetAI))
       RetAttrs.addAttribute(llvm::Attribute::NoUndef);
   }
 
+  auto AddArm64ECX86Sign = [this](QualType Ty, llvm::AttrBuilder &Attrs) {
+    if (Ty->isRecordType() || Ty->isArrayType()) {
+      unsigned SizeInBits = getContext().getTypeSize(Ty.getTypePtr());
+      unsigned SizeInBytes = (SizeInBits + 7) / 8;
+      Attrs.addArmECArgX86SignAttr(SizeInBytes);
+    }
+  };
+
+  if (getTriple().isWindowsArm64EC())
+    AddArm64ECX86Sign(RetTy, RetAttrs);
+
   switch (RetAI.getKind()) {
   case ABIArgInfo::Extend:
     if (RetAI.isSignExt())
       RetAttrs.addAttribute(llvm::Attribute::SExt);
     else
       RetAttrs.addAttribute(llvm::Attribute::ZExt);
     [[fallthrough]];
   case ABIArgInfo::Direct:
for (CGFunctionInfo::const_arg_iterator I = FI.arg_begin(),
     }
 
     // Decide whether the argument we're handling could be partially undef
     if (CodeGenOpts.EnableNoundefAttrs &&
         DetermineNoUndef(ParamType, getTypes(), DL, AI)) {
       Attrs.addAttribute(llvm::Attribute::NoUndef);
     }
 
+    if (getTriple().isWindowsArm64EC())
+      AddArm64ECX86Sign(ParamType, Attrs);
+
     // 'restrict' -> 'noalias' is done in EmitFunctionProlog when we
     // have the corresponding parameter variable.  It doesn't make
     // sense to do it here because parameters are so messed up.
     switch (AI.getKind()) {
     case ABIArgInfo::Extend:
       if (AI.isSignExt())
         Attrs.addAttribute(llvm::Attribute::SExt);
       else

clang/test/CodeGenCXX/arm64ec-mangle-align.cpp

+// RUN: %clang_cc1 %s -triple=arm64ec-pc-windows-msvc -emit-llvm -fms-compatibility -o - | FileCheck %s
+
+extern "C" {
+#pragma pack(push, 1)
+
+struct __declspec(align(1)) s1 {
+  char a[1];
+};
+s1 (*pfnstruct1)(s1 x);
+s1 callstruct1(s1 x) { return pfnstruct1(x); };
+struct __declspec(align(8)) s2 {
+  char a[2];
+};
+s2 (*pfnstruct2)(s2 x);
+s2 callstruct2(s2 x) { return pfnstruct2(x); };
+struct __declspec(align(64)) s3 {
+  char a[3];
+};
+s3 (*pfnstruct3)(s3 x);
+s3 callstruct3(s3 x) { return pfnstruct3(x); };
+struct __declspec(align(32)) s4 {
+  char a[4];
+};
+s4 (*pfnstruct4)(s4 x);
+s4 callstruct4(s4 x) { return pfnstruct4(x); };
+struct __declspec(align(2)) s5 {
+  char a[5];
+};
+s5 (*pfnstruct5)(s5 x);
+s5 callstruct5(s5 x) { return pfnstruct5(x); };
+struct __declspec(align(4)) s6 {
+  char a[6];
+};
+s6 (*pfnstruct6)(s6 x);
+s6 callstruct6(s6 x) { return pfnstruct6(x); };
+struct __declspec(align(8)) s7 {
+  char a[7];
+};
+s7 (*pfnstruct7)(s7 x);
+s7 callstruct7(s7 x) { return pfnstruct7(x); };
+struct __declspec(align(16)) s8 {
+  char a[8];
+};
+s8 (*pfnstruct8)(s8 x);
+s8 callstruct8(s8 x) { return pfnstruct8(x); };
+struct __declspec(align(4)) s9 {
+  char a[9];
+};
+s9 (*pfnstruct9)(s9 x);
+s9 callstruct9(s9 x) { return pfnstruct9(x); };
+struct __declspec(align(2)) s10 {
+  char a[10];
+};
+s10 (*pfnstruct10)(s10 x);
+s10 callstruct10(s10 x) { return pfnstruct10(x); };
+struct __declspec(align(1)) s11 {
+  char a[11];
+};
+s11 (*pfnstruct11)(s11 x);
+s11 callstruct11(s11 x) { return pfnstruct11(x); };
+struct __declspec(align(64)) s12 {
+  char a[12];
+};
+s12 (*pfnstruct12)(s12 x);
+s12 callstruct12(s12 x) { return pfnstruct12(x); };
+struct __declspec(align(8)) s13 {
+  char a[13];
+};
+s13 (*pfnstruct13)(s13 x);
+s13 callstruct13(s13 x) { return pfnstruct13(x); };
+struct __declspec(align(4)) s14 {
+  char a[14];
+};
+s14 (*pfnstruct14)(s14 x);
+s14 callstruct14(s14 x) { return pfnstruct14(x); };
+struct __declspec(align(16)) s15 {
+  char a[15];
+};
+s15 (*pfnstruct15)(s15 x);
+s15 callstruct15(s15 x) { return pfnstruct15(x); };
+struct __declspec(align(32)) s16 {
+  char a[16];
+};
+s16 (*pfnstruct16)(s16 x);
+s16 callstruct16(s16 x) { return pfnstruct16(x); };
+struct __declspec(align(64)) s17 {
+  char a[17];
+};
+s17 (*pfnstruct17)(s17 x);
+s17 callstruct17(s17 x) { return pfnstruct17(x); };
+struct __declspec(align(4)) s33 {
+  char a[33];
+};
+s33 (*pfnstruct33)(s33 x);
+s33 callstruct33(s33 x) { return pfnstruct33(x); };
+struct __declspec(align(2)) s65 {
+  char a[65];
+};
+s65 (*pfnstruct65)(s65 x);
+s65 callstruct65(s65 x) { return pfnstruct65(x); };
+struct __declspec(align(16)) s129 {
+  char a[129];
+};
+s129 (*pfnstruct129)(s129 x);
+s129 callstruct129(s129 x) { return pfnstruct129(x); };
+struct __declspec(align(32)) s257 {
+  char a[257];
+};
+s257 (*pfnstruct257)(s257 x);
+s257 callstruct257(s257 x) { return pfnstruct257(x); };
+
+#pragma pack(pop)
+}
+
+// CHECK: define dso_local arm64ec_x86sign(1) i8 @"#callstruct1"(i64 arm64ec_x86sign(1) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(8) i64 @"#callstruct2"(i64 arm64ec_x86sign(8) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(64) void @"#callstruct3"(ptr noalias sret(%struct.s3) align 64 %agg.result, ptr {{.*}} arm64ec_x86sign(64) %x)
+// CHECK: define dso_local arm64ec_x86sign(32) void @"#callstruct4"(ptr noalias sret(%struct.s4) align 32 %agg.result, ptr {{.*}} arm64ec_x86sign(32) %x)
+// CHECK: define dso_local arm64ec_x86sign(6) i48 @"#callstruct5"(i64 arm64ec_x86sign(6) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(8) i64 @"#callstruct6"(i64 arm64ec_x86sign(8) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(8) i64 @"#callstruct7"(i64 arm64ec_x86sign(8) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(16) i128 @"#callstruct8"(i128 arm64ec_x86sign(16) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(12) [2 x i64] @"#callstruct9"([2 x i64] arm64ec_x86sign(12) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(10) [2 x i64] @"#callstruct10"([2 x i64] arm64ec_x86sign(10) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(11) [2 x i64] @"#callstruct11"([2 x i64] arm64ec_x86sign(11) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(64) void @"#callstruct12"(ptr noalias sret(%struct.s12) align 64 %agg.result, ptr {{.*}} arm64ec_x86sign(64) %x)
+// CHECK: define dso_local arm64ec_x86sign(16) [2 x i64] @"#callstruct13"([2 x i64] arm64ec_x86sign(16) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(16) [2 x i64] @"#callstruct14"([2 x i64] arm64ec_x86sign(16) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(16) i128 @"#callstruct15"(i128 arm64ec_x86sign(16) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(32) void @"#callstruct16"(ptr noalias sret(%struct.s16) align 32 %agg.result, ptr {{.*}} arm64ec_x86sign(32) %x)
+// CHECK: define dso_local arm64ec_x86sign(64) void @"#callstruct17"(ptr noalias sret(%struct.s17) align 64 %agg.result, ptr {{.*}} arm64ec_x86sign(64) %x)
+// CHECK: define dso_local arm64ec_x86sign(36) void @"#callstruct33"(ptr noalias sret(%struct.s33) align 4 %agg.result, ptr {{.*}} arm64ec_x86sign(36) %x)
+// CHECK: define dso_local arm64ec_x86sign(66) void @"#callstruct65"(ptr noalias sret(%struct.s65) align 2 %agg.result, ptr {{.*}} arm64ec_x86sign(66) %x)
+// CHECK: define dso_local arm64ec_x86sign(144) void @"#callstruct129"(ptr noalias sret(%struct.s129) align 16 %agg.result, ptr {{.*}} arm64ec_x86sign(144) %x)
+// CHECK: define dso_local arm64ec_x86sign(288) void @"#callstruct257"(ptr noalias sret(%struct.s257) align 32 %agg.result, ptr {{.*}} arm64ec_x86sign(288) %x)
 No newline at end of file

clang/test/CodeGenCXX/arm64ec-mangle-basic.cpp

+// RUN: %clang_cc1 %s -triple=arm64ec-pc-windows-msvc -emit-llvm -fms-compatibility -o - | FileCheck %s
+extern "C" {
+#pragma pack(push, 1)
+typedef long long i64;
+typedef long double longdouble;
+typedef void *VOIDP;
+bool (*pfnbool)(bool x);
+bool callbool(bool x) { return pfnbool(x); };
+char (*pfnchar)(char x);
+char callchar(char x) { return pfnchar(x); };
+short (*pfnshort)(short x);
+short callshort(short x) { return pfnshort(x); };
+wchar_t (*pfnwchar_t)(wchar_t x);
+wchar_t callwchar_t(wchar_t x) { return pfnwchar_t(x); };
+int (*pfnint)(int x);
+int callint(int x) { return pfnint(x); };
+i64 (*pfni64)(i64 x);
+i64 calli64(i64 x) { return pfni64(x); };
+float (*pfnfloat)(float x);
+float callfloat(float x) { return pfnfloat(x); };
+double (*pfndouble)(double x);
+double calldouble(double x) { return pfndouble(x); };
+longdouble (*pfnlongdouble)(longdouble x);
+longdouble calllongdouble(longdouble x) { return pfnlongdouble(x); };
+VOIDP (*pfnVOIDP)(VOIDP x);
+VOIDP callVOIDP(VOIDP x) { return pfnVOIDP(x); };
+#pragma pack(pop)
+}
+
+// CHECK: define dso_local i1 @"#callbool"(i1 noundef %x)
+// CHECK: define dso_local i8 @"#callchar"(i8 noundef %x)
+// CHECK: define dso_local i16 @"#callshort"(i16 noundef %x)
+// CHECK: define dso_local i16 @"#callwchar_t"(i16 noundef %x)
+// CHECK: define dso_local i32 @"#callint"(i32 noundef %x)
+// CHECK: define dso_local i64 @"#calli64"(i64 noundef %x)
+// CHECK: define dso_local float @"#callfloat"(float noundef %x)
+// CHECK: define dso_local double @"#calldouble"(double noundef %x)
+// CHECK: define dso_local double @"#calllongdouble"(double noundef %x)
+// CHECK: define dso_local ptr @"#callVOIDP"(ptr noundef %x)

clang/test/CodeGenCXX/arm64ec-mangle-struct.cpp

+// RUN: %clang_cc1 %s -triple=arm64ec-pc-windows-msvc -emit-llvm -fms-compatibility -o - | FileCheck %s
+
+extern "C" {
+#pragma pack(push, 1)
+struct s1 {
+  char a[1];
+};
+s1 (*pfnstruct1)(s1 x);
+s1 callstruct1(s1 x) { return pfnstruct1(x); };
+struct s2 {
+  char a[2];
+};
+s2 (*pfnstruct2)(s2 x);
+s2 callstruct2(s2 x) { return pfnstruct2(x); };
+struct s3 {
+  char a[3];
+};
+s3 (*pfnstruct3)(s3 x);
+s3 callstruct3(s3 x) { return pfnstruct3(x); };
+struct s4 {
+  char a[4];
+};
+s4 (*pfnstruct4)(s4 x);
+s4 callstruct4(s4 x) { return pfnstruct4(x); };
+struct s5 {
+  char a[5];
+};
+s5 (*pfnstruct5)(s5 x);
+s5 callstruct5(s5 x) { return pfnstruct5(x); };
+struct s6 {
+  char a[6];
+};
+s6 (*pfnstruct6)(s6 x);
+s6 callstruct6(s6 x) { return pfnstruct6(x); };
+struct s7 {
+  char a[7];
+};
+s7 (*pfnstruct7)(s7 x);
+s7 callstruct7(s7 x) { return pfnstruct7(x); };
+struct s8 {
+  char a[8];
+};
+s8 (*pfnstruct8)(s8 x);
+s8 callstruct8(s8 x) { return pfnstruct8(x); };
+struct s9 {
+  char a[9];
+};
+s9 (*pfnstruct9)(s9 x);
+s9 callstruct9(s9 x) { return pfnstruct9(x); };
+struct s10 {
+  char a[10];
+};
+s10 (*pfnstruct10)(s10 x);
+s10 callstruct10(s10 x) { return pfnstruct10(x); };
+struct s11 {
+  char a[11];
+};
+s11 (*pfnstruct11)(s11 x);
+s11 callstruct11(s11 x) { return pfnstruct11(x); };
+struct s12 {
+  char a[12];
+};
+s12 (*pfnstruct12)(s12 x);
+s12 callstruct12(s12 x) { return pfnstruct12(x); };
+struct s13 {
+  char a[13];
+};
+s13 (*pfnstruct13)(s13 x);
+s13 callstruct13(s13 x) { return pfnstruct13(x); };
+struct s14 {
+  char a[14];
+};
+s14 (*pfnstruct14)(s14 x);
+s14 callstruct14(s14 x) { return pfnstruct14(x); };
+struct s15 {
+  char a[15];
+};
+s15 (*pfnstruct15)(s15 x);
+s15 callstruct15(s15 x) { return pfnstruct15(x); };
+struct s16 {
+  char a[16];
+};
+s16 (*pfnstruct16)(s16 x);
+s16 callstruct16(s16 x) { return pfnstruct16(x); };
+struct s17 {
+  char a[17];
+};
+s17 (*pfnstruct17)(s17 x);
+s17 callstruct17(s17 x) { return pfnstruct17(x); };
+struct s32 {
+  char a[32];
+};
+s32 (*pfnstruct32)(s32 x);
+s32 callstruct32(s32 x) { return pfnstruct32(x); };
+struct s33 {
+  char a[33];
+};
+s33 (*pfnstruct33)(s33 x);
+s33 callstruct33(s33 x) { return pfnstruct33(x); };
+struct s64 {
+  char a[64];
+};
+s64 (*pfnstruct64)(s64 x);
+s64 callstruct64(s64 x) { return pfnstruct64(x); };
+struct s65 {
+  char a[65];
+};
+s65 (*pfnstruct65)(s65 x);
+s65 callstruct65(s65 x) { return pfnstruct65(x); };
+struct s128 {
+  char a[128];
+};
+s128 (*pfnstruct128)(s128 x);
+s128 callstruct128(s128 x) { return pfnstruct128(x); };
+struct s133 {
+  char a[133];
+};
+s133 (*pfnstruct133)(s133 x);
+s133 callstruct133(s133 x) { return pfnstruct133(x); };
+struct s192 {
+  char a[192];
+};
+s192 (*pfnstruct192)(s192 x);
+s192 callstruct192(s192 x) { return pfnstruct192(x); };
+struct s223 {
+  char a[223];
+};
+s223 (*pfnstruct223)(s223 x);
+s223 callstruct223(s223 x) { return pfnstruct223(x); };
+struct s256 {
+  char a[256];
+};
+s256 (*pfnstruct256)(s256 x);
+s256 callstruct256(s256 x) { return pfnstruct256(x); };
+struct s257 {
+  char a[257];
+};
+s257 (*pfnstruct257)(s257 x);
+s257 callstruct257(s257 x) { return pfnstruct257(x); };
+#pragma pack(pop)
+}
+
+// CHECK: define dso_local arm64ec_x86sign(1) i8 @"#callstruct1"(i64 arm64ec_x86sign(1) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(2) i16 @"#callstruct2"(i64 arm64ec_x86sign(2) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(3) i24 @"#callstruct3"(i64 arm64ec_x86sign(3) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(4) i32 @"#callstruct4"(i64 arm64ec_x86sign(4) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(5) i40 @"#callstruct5"(i64 arm64ec_x86sign(5) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(6) i48 @"#callstruct6"(i64 arm64ec_x86sign(6) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(7) i56 @"#callstruct7"(i64 arm64ec_x86sign(7) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(8) i64 @"#callstruct8"(i64 arm64ec_x86sign(8) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(9) [2 x i64] @"#callstruct9"([2 x i64] arm64ec_x86sign(9) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(10) [2 x i64] @"#callstruct10"([2 x i64] arm64ec_x86sign(10) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(11) [2 x i64] @"#callstruct11"([2 x i64] arm64ec_x86sign(11) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(12) [2 x i64] @"#callstruct12"([2 x i64] arm64ec_x86sign(12) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(13) [2 x i64] @"#callstruct13"([2 x i64] arm64ec_x86sign(13) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(14) [2 x i64] @"#callstruct14"([2 x i64] arm64ec_x86sign(14) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(15) [2 x i64] @"#callstruct15"([2 x i64] arm64ec_x86sign(15) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(16) [2 x i64] @"#callstruct16"([2 x i64] arm64ec_x86sign(16) %x.coerce)
+// CHECK: define dso_local arm64ec_x86sign(17) void @"#callstruct17"(ptr noalias sret(%struct.s17) align 1 %agg.result, ptr {{.*}} arm64ec_x86sign(17) %x)
+// CHECK: define dso_local arm64ec_x86sign(32) void @"#callstruct32"(ptr noalias sret(%struct.s32) align 1 %agg.result, ptr {{.*}} arm64ec_x86sign(32) %x)
+// CHECK: define dso_local arm64ec_x86sign(33) void @"#callstruct33"(ptr noalias sret(%struct.s33) align 1 %agg.result, ptr {{.*}} arm64ec_x86sign(33) %x)
+// CHECK: define dso_local arm64ec_x86sign(64) void @"#callstruct64"(ptr noalias sret(%struct.s64) align 1 %agg.result, ptr {{.*}} arm64ec_x86sign(64) %x)
+// CHECK: define dso_local arm64ec_x86sign(65) void @"#callstruct65"(ptr noalias sret(%struct.s65) align 1 %agg.result, ptr {{.*}} arm64ec_x86sign(65) %x)
+// CHECK: define dso_local arm64ec_x86sign(128) void @"#callstruct128"(ptr noalias sret(%struct.s128) align 1 %agg.result, ptr {{.*}} arm64ec_x86sign(128) %x)
+// CHECK: define dso_local arm64ec_x86sign(133) void @"#callstruct133"(ptr noalias sret(%struct.s133) align 1 %agg.result, ptr {{.*}} arm64ec_x86sign(133) %x)
+// CHECK: define dso_local arm64ec_x86sign(192) void @"#callstruct192"(ptr noalias sret(%struct.s192) align 1 %agg.result, ptr {{.*}} arm64ec_x86sign(192) %x)
+// CHECK: define dso_local arm64ec_x86sign(223) void @"#callstruct223"(ptr noalias sret(%struct.s223) align 1 %agg.result, ptr {{.*}} arm64ec_x86sign(223) %x)
+// CHECK: define dso_local arm64ec_x86sign(256) void @"#callstruct256"(ptr noalias sret(%struct.s256) align 1 %agg.result, ptr {{.*}} arm64ec_x86sign(256) %x)
+// CHECK: define dso_local arm64ec_x86sign(257) void @"#callstruct257"(ptr noalias sret(%struct.s257) align 1 %agg.result, ptr {{.*}} arm64ec_x86sign(257) %x)

clang/test/CodeGenCXX/arm64ec.cpp

 // RUN: %clang_cc1 -no-opaque-pointers -triple arm64ec-windows-msvc -emit-llvm -o - %s | FileCheck %s
 
 // CHECK: @"?g@@YAXUA@@UB@@@Z" = alias void ([2 x float], [4 x float]), void ([2 x float], [4 x float])* @"?g@@$$hYAXUA@@UB@@@Z"
 // CHECK: define dso_local void @"?g@@$$hYAXUA@@UB@@@Z"
-// CHECK: call void (i64, ...) @"?f@@YAXUA@@ZZ"(i64 %{{.*}}, %struct.B* noundef %{{.*}})
+// CHECK: call void (i64, ...) @"?f@@YAXUA@@ZZ"(i64 arm64ec_x86sign(8) %{{.*}}, %struct.B* noundef arm64ec_x86sign(16) %{{.*}})
 typedef struct { float x[2]; } A;
 typedef struct { float x[4]; } B;
 void f(A a, ...);
 void g(A a, B b) { f(a, b); }

llvm/include/llvm/Bitcode/LLVMBitCodes.h

enum AttributeKindCodes {
   ATTR_KIND_DISABLE_SANITIZER_INSTRUMENTATION = 78,
   ATTR_KIND_NO_SANITIZE_BOUNDS = 79,
   ATTR_KIND_ALLOC_ALIGN = 80,
   ATTR_KIND_ALLOCATED_POINTER = 81,
   ATTR_KIND_ALLOC_KIND = 82,
   ATTR_KIND_PRESPLIT_COROUTINE = 83,
   ATTR_KIND_FNRETTHUNK_EXTERN = 84,
   ATTR_KIND_SKIP_PROFILE = 85,
+  ATTR_KIND_ARM64EC_ARG_X86SIGN = 86,
 };
 
 enum ComdatSelectionKindCodes {
   COMDAT_SELECTION_KIND_ANY = 1,
   COMDAT_SELECTION_KIND_EXACT_MATCH = 2,
   COMDAT_SELECTION_KIND_LARGEST = 3,
   COMDAT_SELECTION_KIND_NO_DUPLICATES = 4,
   COMDAT_SELECTION_KIND_SAME_SIZE = 5,

llvm/include/llvm/IR/Attributes.h

public:
   static Attribute getWithVScaleRangeArgs(LLVMContext &Context,
                                           unsigned MinValue, unsigned MaxValue);
   static Attribute getWithByValType(LLVMContext &Context, Type *Ty);
   static Attribute getWithStructRetType(LLVMContext &Context, Type *Ty);
   static Attribute getWithByRefType(LLVMContext &Context, Type *Ty);
   static Attribute getWithPreallocatedType(LLVMContext &Context, Type *Ty);
   static Attribute getWithInAllocaType(LLVMContext &Context, Type *Ty);
   static Attribute getWithUWTableKind(LLVMContext &Context, UWTableKind Kind);
+  static Attribute getWithArm64ECArgX86SignBytes(LLVMContext &Context,
+                                                 uint64_t Bytes);
 
   /// For a typed attribute, return the equivalent attribute with the type
   /// changed to \p ReplacementTy.
   Attribute getWithNewType(LLVMContext &Context, Type *ReplacementTy) {
     assert(isTypeAttribute() && "this requires a typed attribute");
     return get(Context, getKindAsEnum(), ReplacementTy);
   }
 
public:
   Optional<unsigned> getVScaleRangeMax() const;
 
   // Returns the unwind table kind.
   UWTableKind getUWTableKind() const;
 
   // Returns the allocator function kind.
   AllocFnKind getAllocKind() const;
 
+  /// Returns arm64ec x86 signature arg size in bytes
+  uint64_t getArm64ECArgX86SignBytes() const;
+
   /// The Attribute is converted to a string of equivalent mnemonic. This
   /// is, presumably, for writing out the mnemonics for the assembly writer.
   std::string getAsString(bool InAttrGrp = false) const;
 
   /// Return true if this attribute belongs to the LLVMContext.
   bool hasParentContext(LLVMContext &C) const;
 
   /// Equality and non-equality operators.
public:
   Type *getPreallocatedType() const;
   Type *getInAllocaType() const;
   Type *getElementType() const;
   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
   unsigned getVScaleRangeMin() const;
   Optional<unsigned> getVScaleRangeMax() const;
   UWTableKind getUWTableKind() const;
   AllocFnKind getAllocKind() const;
+  uint64_t getArm64ECArgX86SignBytes() const;
   std::string getAsString(bool InAttrGrp = false) const;
 
   /// Return true if this attribute set belongs to the LLVMContext.
   bool hasParentContext(LLVMContext &C) const;
 
   using iterator = const Attribute *;
 
   iterator begin() const;
public:
   /// arg.
   uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const;
 
   /// Get the unwind table kind requested for the function.
   UWTableKind getUWTableKind() const;
 
   AllocFnKind getAllocKind() const;
 
+  /// Get the number of Arm64ECArgX86Sign bytes (or zero if unknown) of the
+  /// return value.
+  uint64_t getRetArm64ECArgX86SignBytes() const;
+
+  /// Get the number of Arm64ECArgX86Sign bytes (or zero if unknown) of an arg.
+  uint64_t getParamArm64ECArgX86SignBytes(unsigned Index) const;
+
   /// Return the attributes at the index as a string.
   std::string getAsString(unsigned Index, bool InAttrGrp = false) const;
 
   /// Return true if this attribute list belongs to the LLVMContext.
   bool hasParentContext(LLVMContext &C) const;
 
   //===--------------------------------------------------------------------===//
   // AttributeList Introspection
public:
   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
 
   /// Retrieve the minimum value of 'vscale_range'.
   unsigned getVScaleRangeMin() const;
 
   /// Retrieve the maximum value of 'vscale_range' or None when unknown.
   Optional<unsigned> getVScaleRangeMax() const;
 
+  /// Retrieve the arm64ec x86 signature size attribute, if it exists.
+  uint64_t getArm64ECArgX86SignBytes() const {
+    return getRawIntAttr(Attribute::Arm64ECArgX86Sign);
+  }
+
   /// Add integer attribute with raw value (packed/encoded if necessary).
   AttrBuilder &addRawIntAttr(Attribute::AttrKind Kind, uint64_t Value);
 
   /// This turns an alignment into the form used internally in Attribute.
   /// This call has no effect if Align is not set.
   AttrBuilder &addAlignmentAttr(MaybeAlign Align);
 
   /// This turns an int alignment (which must be a power of 2) into the
public:
   /// Add an allocsize attribute, using the representation returned by
   /// Attribute.getIntValue().
   AttrBuilder &addAllocSizeAttrFromRawRepr(uint64_t RawAllocSizeRepr);
 
   /// Add a vscale_range attribute, using the representation returned by
   /// Attribute.getIntValue().
   AttrBuilder &addVScaleRangeAttrFromRawRepr(uint64_t RawVScaleRangeRepr);
 
+  /// This turns the number of arm64ec args with x86 signature bytes into the
+  /// form used internally in Attribute.
+  AttrBuilder &addArmECArgX86SignAttr(uint64_t Bytes);
+
   /// This turns the unwind table kind into the form used internally in
   /// Attribute.
   AttrBuilder &addUWTableAttr(UWTableKind Kind);
 
   // This turns the allocator kind into the form used internally in Attribute.
   AttrBuilder &addAllocKindAttr(AllocFnKind Kind);
 
   ArrayRef<Attribute> attrs() const { return Attrs; }

llvm/include/llvm/IR/Attributes.td

 def ZExt : EnumAttr<"zeroext", [ParamAttr, RetAttr]>;
 
 /// Function is required to make Forward Progress.
 def MustProgress : EnumAttr<"mustprogress", [FnAttr]>;
 
 /// Function is a presplit coroutine.
 def PresplitCoroutine : EnumAttr<"presplitcoroutine", [FnAttr]>;
 
+/// Struct Arg size for x86 signature to generate correct thunk
+def Arm64ECArgX86Sign : IntAttr<"arm64ec_x86sign", [ParamAttr, RetAttr]>;
+
 /// Target-independent string attributes.
 def LessPreciseFPMAD : StrBoolAttr<"less-precise-fpmad">;
 def NoInfsFPMath : StrBoolAttr<"no-infs-fp-math">;
 def NoNansFPMath : StrBoolAttr<"no-nans-fp-math">;
 def ApproxFuncFPMath : StrBoolAttr<"approx-func-fp-math">;
 def NoSignedZerosFPMath : StrBoolAttr<"no-signed-zeros-fp-math">;
 def UnsafeFPMath : StrBoolAttr<"unsafe-fp-math">;
 def NoJumpTables : StrBoolAttr<"no-jump-tables">;

llvm/include/llvm/IR/InstrTypes.h

public:
   }
 
   /// Extract the number of dereferenceable_or_null bytes for a
   /// parameter (0=unknown).
   uint64_t getParamDereferenceableOrNullBytes(unsigned i) const {
     return Attrs.getParamDereferenceableOrNullBytes(i);
   }
 
+  /// Extract the number of Arm64ECArgX86Sign bytes for a call or
+  /// parameter.
+  uint64_t getRetArm64ECArgX86SignBytes() const {
+    return Attrs.getRetArm64ECArgX86SignBytes();
+  }
+
+  /// Extract the number of Arm64ECArgX86Sign bytes for a call or
+  /// parameter.
+  uint64_t getParamArm64ECArgX86SignBytes(unsigned i) const {
+    return Attrs.getParamArm64ECArgX86SignBytes(i);
+  }
+
   /// Return true if the return value is known to be not null.
   /// This may be because it has the nonnull attribute, or because at least
   /// one byte is dereferenceable and the pointer is in addrspace(0).
   bool isReturnNonNull() const;
 
   /// Determine if the return value is marked with NoAlias attribute.
   bool returnDoesNotAlias() const {
     return Attrs.hasRetAttr(Attribute::NoAlias);

llvm/lib/AsmParser/LLParser.cpp

bool LLParser::parseEnumAttribute(Attribute::AttrKind Attr, AttrBuilder &B,
   }
   case Attribute::AllocKind: {
     AllocFnKind Kind = AllocFnKind::Unknown;
     if (parseAllocKind(Kind))
       return true;
     B.addAllocKindAttr(Kind);
     return false;
   }
+  case Attribute::Arm64ECArgX86Sign: {
+    if (!EatIfPresent(lltok::kw_arm64ec_x86sign))
+      return false;
+    LocTy ParenLoc = Lex.getLoc();
+    if (!EatIfPresent(lltok::lparen))
+      return error(ParenLoc, "expected '('");
+    uint64_t Bytes = 0;
+    if (parseUInt64(Bytes))
+      return true;
+    ParenLoc = Lex.getLoc();
+    if (!EatIfPresent(lltok::rparen))
+      return error(ParenLoc, "expected ')'");
+    B.addArmECArgX86SignAttr(Bytes);
+    return false;
+  }
   default:
     B.addAttribute(Attr);
     Lex.Lex();
     return false;
   }
 }
 
 /// parseFnAttributeValuePairs

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

static Attribute::AttrKind getAttrFromCode(uint64_t Code) {
   case bitc::ATTR_KIND_BYREF:
     return Attribute::ByRef;
   case bitc::ATTR_KIND_MUSTPROGRESS:
     return Attribute::MustProgress;
   case bitc::ATTR_KIND_HOT:
     return Attribute::Hot;
   case bitc::ATTR_KIND_PRESPLIT_COROUTINE:
     return Attribute::PresplitCoroutine;
+  case bitc::ATTR_KIND_ARM64EC_ARG_X86SIGN:
+    return Attribute::Arm64ECArgX86Sign;
   }
 }
 
 Error BitcodeReader::parseAlignmentValue(uint64_t Exponent,
                                          MaybeAlign &Alignment) {
   // Note: Alignment in bitcode files is incremented by 1, so that zero
   // can be used for default alignment.
   if (Exponent > Value::MaxAlignmentExponent + 1)

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
   case Attribute::NoUndef:
     return bitc::ATTR_KIND_NOUNDEF;
   case Attribute::ByRef:
     return bitc::ATTR_KIND_BYREF;
   case Attribute::MustProgress:
     return bitc::ATTR_KIND_MUSTPROGRESS;
   case Attribute::PresplitCoroutine:
     return bitc::ATTR_KIND_PRESPLIT_COROUTINE;
+  case Attribute::Arm64ECArgX86Sign:
+    return bitc::ATTR_KIND_ARM64EC_ARG_X86SIGN;
   case Attribute::EndAttrKinds:
     llvm_unreachable("Can not encode end-attribute kinds marker.");
   case Attribute::None:
     llvm_unreachable("Can not encode none-attribute.");
   case Attribute::EmptyKey:
   case Attribute::TombstoneKey:
     llvm_unreachable("Trying to encode EmptyKey/TombstoneKey");
   }

llvm/lib/IR/AttributeImpl.h

public:
   MaybeAlign getStackAlignment() const;
   uint64_t getDereferenceableBytes() const;
   uint64_t getDereferenceableOrNullBytes() const;
   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
   unsigned getVScaleRangeMin() const;
   Optional<unsigned> getVScaleRangeMax() const;
   UWTableKind getUWTableKind() const;
   AllocFnKind getAllocKind() const;
+  uint64_t getArm64ECArgX86SignBytes() const;
   std::string getAsString(bool InAttrGrp) const;
   Type *getAttributeType(Attribute::AttrKind Kind) const;
 
   using iterator = const Attribute *;
 
   iterator begin() const { return getTrailingObjects<Attribute>(); }
   iterator end() const { return begin() + NumAttrs; }
 

llvm/lib/IR/Attributes.cpp

 }
 
 Attribute Attribute::getWithVScaleRangeArgs(LLVMContext &Context,
                                             unsigned MinValue,
                                             unsigned MaxValue) {
   return get(Context, VScaleRange, packVScaleRangeArgs(MinValue, MaxValue));
 }
 
+Attribute Attribute::getWithArm64ECArgX86SignBytes(LLVMContext &Context,
+                                                   uint64_t Bytes) {
+  return get(Context, Arm64ECArgX86Sign, Bytes);
+}
+
 Attribute::AttrKind Attribute::getAttrKindFromName(StringRef AttrName) {
   return StringSwitch<Attribute::AttrKind>(AttrName)
 #define GET_ATTR_NAMES
 #define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME)                                \
   .Case(#DISPLAY_NAME, Attribute::ENUM_NAME)
 #include "llvm/IR/Attributes.inc"
       .Default(Attribute::None);
 }

 }
 
 Optional<unsigned> Attribute::getVScaleRangeMax() const {
   assert(hasAttribute(Attribute::VScaleRange) &&
          "Trying to get vscale args from non-vscale attribute");
   return unpackVScaleRangeArgs(pImpl->getValueAsInt()).second;
 }
 
+uint64_t Attribute::getArm64ECArgX86SignBytes() const {
+  assert(hasAttribute(Attribute::Arm64ECArgX86Sign) &&
+         "Trying to get Arm64ECArgX86Sign bytes from "
+         "non-Arm64ECArgX86Sign attribute!");
+  return pImpl->getValueAsInt();
+}
+
 UWTableKind Attribute::getUWTableKind() const {
   assert(hasAttribute(Attribute::UWTable) &&
          "Trying to get unwind table kind from non-uwtable attribute");
   return UWTableKind(pImpl->getValueAsInt());
 }
 
 AllocFnKind Attribute::getAllocKind() const {
   assert(hasAttribute(Attribute::AllocKind) &&
if ((Kind & AllocFnKind::Zeroed) != AllocFnKind::Unknown)
       parts.push_back("zeroed");
     if ((Kind & AllocFnKind::Aligned) != AllocFnKind::Unknown)
       parts.push_back("aligned");
     return ("allockind(\"" +
             Twine(llvm::join(parts.begin(), parts.end(), ",")) + "\")")
         .str();
   }
 
+  if (hasAttribute(Attribute::Arm64ECArgX86Sign))
+    return AttrWithBytesToString("arm64ec_x86sign");
+
   // Convert target-dependent attributes to strings of the form:
   //
   //   "kind"
   //   "kind" = "value"
   //
   if (isStringAttribute()) {
     std::string Result;
     {

 UWTableKind AttributeSet::getUWTableKind() const {
   return SetNode ? SetNode->getUWTableKind() : UWTableKind::None;
 }
 
 AllocFnKind AttributeSet::getAllocKind() const {
   return SetNode ? SetNode->getAllocKind() : AllocFnKind::Unknown;
 }
 
+uint64_t AttributeSet::getArm64ECArgX86SignBytes() const {
+  return SetNode ? SetNode->getArm64ECArgX86SignBytes() : 0;
+}
+
 std::string AttributeSet::getAsString(bool InAttrGrp) const {
   return SetNode ? SetNode->getAsString(InAttrGrp) : "";
 }
 
 bool AttributeSet::hasParentContext(LLVMContext &C) const {
   assert(hasAttributes() && "empty AttributeSet doesn't refer to any context");
   FoldingSetNodeID ID;
   SetNode->Profile(ID);

 }
 
 AllocFnKind AttributeSetNode::getAllocKind() const {
   if (auto A = findEnumAttribute(Attribute::AllocKind))
     return A->getAllocKind();
   return AllocFnKind::Unknown;
 }
 
+uint64_t AttributeSetNode::getArm64ECArgX86SignBytes() const {
+  if (auto A = findEnumAttribute(Attribute::Arm64ECArgX86Sign))
+    return A->getArm64ECArgX86SignBytes();
+  return 0;
+}
+
 std::string AttributeSetNode::getAsString(bool InAttrGrp) const {
   std::string Str;
   for (iterator I = begin(), E = end(); I != E; ++I) {
     if (I != begin())
       Str += ' ';
     Str += I->getAsString(InAttrGrp);
   }
   return Str;

 UWTableKind AttributeList::getUWTableKind() const {
   return getFnAttrs().getUWTableKind();
 }
 
 AllocFnKind AttributeList::getAllocKind() const {
   return getFnAttrs().getAllocKind();
 }
 
+uint64_t AttributeList::getRetArm64ECArgX86SignBytes() const {
+  return getRetAttrs().getArm64ECArgX86SignBytes();
+}
+
+uint64_t AttributeList::getParamArm64ECArgX86SignBytes(unsigned Index) const {
+  return getParamAttrs(Index).getArm64ECArgX86SignBytes();
+}
+
 std::string AttributeList::getAsString(unsigned Index, bool InAttrGrp) const {
   return getAttributes(Index).getAsString(InAttrGrp);
 }
 
 AttributeSet AttributeList::getAttributes(unsigned Index) const {
   Index = attrIdxToArrayIdx(Index);
   if (!pImpl || Index >= getNumAttrSets())
     return {};

 AttrBuilder &AttrBuilder::addVScaleRangeAttrFromRawRepr(uint64_t RawArgs) {
   // (0, 0) is not present hence ignore this case
   if (RawArgs == 0)
     return *this;
 
   return addRawIntAttr(Attribute::VScaleRange, RawArgs);
 }
 
+AttrBuilder &AttrBuilder::addArmECArgX86SignAttr(uint64_t Bytes) {
+  return addRawIntAttr(Attribute::Arm64ECArgX86Sign, Bytes);
+}
+
 AttrBuilder &AttrBuilder::addUWTableAttr(UWTableKind Kind) {
   if (Kind == UWTableKind::None)
     return *this;
   return addRawIntAttr(Attribute::UWTable, uint64_t(Kind));
 }
 
 AttrBuilder &AttrBuilder::addAllocKindAttr(AllocFnKind Kind) {
   return addRawIntAttr(Attribute::AllocKind, static_cast<uint64_t>(Kind));

llvm/lib/Transforms/Utils/CodeExtractor.cpp

if (Attr.isStringAttribute()) {
       case Attribute::SExt:
       case Attribute::StructRet:
       case Attribute::SwiftError:
       case Attribute::SwiftSelf:
       case Attribute::SwiftAsync:
       case Attribute::ZExt:
       case Attribute::ImmArg:
       case Attribute::ByRef:
+      case Attribute::Arm64ECArgX86Sign:
       //  These are not really attributes.
       case Attribute::None:
       case Attribute::EndAttrKinds:
       case Attribute::EmptyKey:
       case Attribute::TombstoneKey:
         llvm_unreachable("Not a function attribute");
       }