MS inline asm: remove obsolete code adding AOK_SizeDirective (e.g. dword ptr)

[MaskRay]

Summary

The AOK_SizeDirective part from 5b37c181291210bedfbb7a6af5d51229f3652ef0
(2014-08) seems unneeded nowadays (the root cause has likely been fixed
elsewhere). The part abuses that call dword ptr foo assembles the same way as `call
foo` in Intel syntax, which is going to be fixed (changed) by D149579.

The generated object files for CodeGen/ms-inline-asm-functions.c,
CodeGen/ms-inline-asm-functions.c, and CodeGenCXX/ms-inline-asm-fields.cpp are
unchanged with just this patch.
When D149579 is subsequently applied, the FIXME part of kptr in
CodeGen/ms-inline-asm-functions.c will be fixed.

[hans]

The AOK_SizeDirective part from 5b37c181291210bedfbb7a6af5d51229f3652ef0
(2014-08) seems unneeded nowadays (the root cause has likely been fixed
elsewhere).

Would it be possible to confirm when/if the size directive here became unnecessary?

[MaskRay]

In D149695#4315194, @hans wrote:

The AOK_SizeDirective part from 5b37c181291210bedfbb7a6af5d51229f3652ef0
(2014-08) seems unneeded nowadays (the root cause has likely been fixed
elsewhere).

Would it be possible to confirm when/if the size directive here became unnecessary?

I compared the assembled output from C test files. They are identical. (I know it would be best to prove this by fully understanding the logic, but that appears difficult...)

The generated object files for CodeGen/ms-inline-asm-functions.c, CodeGen/ms-inline-asm-functions.c, and CodeGenCXX/ms-inline-asm-fields.cpp are unchanged with just this patch.

When D149579 is subsequently applied, the FIXME part of kptr in CodeGen/ms-inline-asm-functions.c will be fixed.

[hans]

lgtm

clang/test/CodeGen/mozilla-ms-inline-asm.c

 // CHECK-SAME: test edx,edx
 // CHECK-SAME: jz {{[^_]*}}__MSASMLABEL_.${:uid}__noparams
 //                ^ Can't use {{.*}} here because the matching is greedy.
 // CHECK-SAME: mov eax,edx
 // CHECK-SAME: shl eax,$$3
 // CHECK-SAME: sub esp,eax
 // CHECK-SAME: mov ecx,esp
 // CHECK-SAME: push $0
-// CHECK-SAME: call dword ptr ${2:P}
+// CHECK-SAME: call ${2:P}
 // CHECK-SAME: {{.*}}__MSASMLABEL_.${:uid}__noparams:
 // CHECK-SAME: mov ecx,$3
 // CHECK-SAME: push ecx
 // CHECK-SAME: mov edx,[ecx]
 // CHECK-SAME: mov eax,$4
 // CHECK-SAME: call dword ptr[edx + eax * $$4]
 // CHECK-SAME: mov esp,ebp
 // CHECK-SAME: pop ebp

clang/test/CodeGen/ms-inline-asm-64.c

 
 void t5(void) {
   __asm {
     call bar
     jmp bar
   }
   // CHECK: t5
   // CHECK: call void asm sideeffect inteldialect
-  // CHECK-SAME: call qword ptr ${0:P}
-  // CHECK-SAME: jmp qword ptr ${1:P}
+  // CHECK-SAME: call ${0:P}
+  // CHECK-SAME: jmp ${1:P}
   // CHECK-SAME: "*m,*m,~{dirflag},~{fpsr},~{flags}"(ptr elementtype(void (...)) @bar, ptr elementtype(void (...)) @bar)
 }

clang/test/CodeGen/ms-inline-asm.c

 // CHECK: t23
 // CHECK: call void asm sideeffect inteldialect "{{.*}}__MSASMLABEL_.${:uid}__the_label:", "~{dirflag},~{fpsr},~{flags}"()
 }
 
 void t24_helper(void) {}
 void t24(void) {
   __asm call t24_helper
 // CHECK: t24
-// CHECK: call void asm sideeffect inteldialect "call dword ptr ${0:P}", "*m,~{dirflag},~{fpsr},~{flags}"(ptr elementtype(void ()) @t24_helper)
+// CHECK: call void asm sideeffect inteldialect "call ${0:P}", "*m,~{dirflag},~{fpsr},~{flags}"(ptr elementtype(void ()) @t24_helper)
 }
 
 void t25(void) {
 // CHECK: t25
   __asm mov eax, 0ffffffffh
 // CHECK: mov eax, $$4294967295
   __asm mov eax, 0fhU
 // CHECK: mov eax, $$15
void dot_operator(void){
   // CHECK-LABEL: define{{.*}} void @dot_operator
   __asm { mov eax, 3[ebx]A.b}
   // CHECK: call void asm sideeffect inteldialect "mov eax, [ebx + $$7]", "~{eax},~{dirflag},~{fpsr},~{flags}"
 }
 
 void call_clobber(void) {
   __asm call t41
   // CHECK-LABEL: define{{.*}} void @call_clobber
-  // CHECK: call void asm sideeffect inteldialect "call dword ptr ${0:P}", "*m,~{dirflag},~{fpsr},~{flags}"(ptr elementtype(void (i16)) @t41)
+  // CHECK: call void asm sideeffect inteldialect "call ${0:P}", "*m,~{dirflag},~{fpsr},~{flags}"(ptr elementtype(void (i16)) @t41)
 }
 
 void xgetbv(void) {
   __asm xgetbv
 }
 // CHECK-LABEL: define{{.*}} void @xgetbv()
 // CHECK: call void asm sideeffect inteldialect "xgetbv", "~{eax},~{edx},~{dirflag},~{fpsr},~{flags}"()
 

clang/test/CodeGen/ms-inline-asm.cpp

void test5() {
   // CHECK: [[X:%.*]] = alloca i32
   // CHECK: [[Y:%.*]] = alloca i32
   int x, y;
   __asm push y
   __asm call T5<int>::create<float>
   __asm mov x, eax
   // CHECK: call void asm sideeffect inteldialect
   // CHECK-SAME: push $0
-  // CHECK-SAME: call dword ptr ${2:P}
+  // CHECK-SAME: call ${2:P}
   // CHECK-SAME: mov $1, eax
   // CHECK-SAME: "=*m,=*m,*m,~{esp},~{dirflag},~{fpsr},~{flags}"(ptr elementtype(i32) %y, ptr elementtype(i32) %x, ptr elementtype(i32 (float)) @_ZN2T5IiE6createIfEEiT_)
 }
 
 // Just verify this doesn't emit an error.
 void test6() {
   __asm {
    a:

clang/test/CodeGen/ms_this.cpp

 
 // CHECK: define dso_local void @"?runc@t2@@
 void t2::runc() {
   double num = 0;
   __asm {
       mov rax,[this]
       // CHECK: [[THIS_ADDR_T2:%.+]] = alloca ptr
       // CHECK: [[THIS1_T2:%.+]] = load ptr, ptr [[THIS_ADDR_T2]],
-      // CHECK: call void asm sideeffect inteldialect "mov rax,qword ptr $1{{.*}}ptr [[THIS1_T2]]
+      // CHECK: call void asm sideeffect inteldialect "mov rax,$1\0A\09mov rbx,[rax]\0A\09mov $0, rbx", "=*m,m,~{rax},~{rbx},~{dirflag},~{fpsr},~{flags}"(ptr elementtype(double) %num, ptr [[THIS1_T2]])
       mov rbx,[rax]
       mov num, rbx
      };
 }
 
 // CHECK: define dso_local void @"?runc@t1@@
 void t1::runc() {
   double num = 0;
   __asm {
        mov rax,[this]
        // CHECK: [[THIS_ADDR_T1:%.+]] = alloca ptr
        // CHECK: [[THIS1_T1:%.+]] = load ptr, ptr [[THIS_ADDR_T1]],
-       // CHECK: call void asm sideeffect inteldialect "mov rax,qword ptr $1{{.*}}ptr [[THIS1_T1]]
+       // CHECK: call void asm sideeffect inteldialect "mov rax,$1{{.*}}ptr [[THIS1_T1]]
         mov rbx,[rax]
         mov num, rbx
      };
 }
 
 struct s {
   int a;
   // CHECK: define linkonce_odr dso_local void @"?func@s@@
   void func() {
     __asm mov rax, [this]
     // CHECK: [[THIS_ADDR_S:%.+]] = alloca ptr
     // CHECK: [[THIS1_S:%.+]] = load ptr, ptr [[THIS_ADDR_S]],
-    // CHECK: call void asm sideeffect inteldialect "mov rax, qword ptr $0{{.*}}ptr [[THIS1_S]]
+    // CHECK: call void asm sideeffect inteldialect "mov rax, $0{{.*}}ptr [[THIS1_S]]
   }
 } f3;
 
 int main() {
   f3.func();
   f3.a=1;
   return 0;
 }

clang/test/CodeGenCXX/ms-inline-asm-fields.cpp

struct msvc_dcas_x86 {
   }
 };
 
 template void msvc_dcas_x86<false>::store();
 // CHECK: define weak_odr void @"\01PR26001"(
 // CHECK: %[[P:.*]] = alloca %"struct.make_storage_type<false>::type", align 4
 // CHECK: %[[B:.*]] = getelementptr inbounds %"struct.make_storage_type<false>::type", ptr %[[P]], i32 0, i32 0
 // CHECK: %[[X:.*]] = getelementptr inbounds %"struct.make_storage_type<false>::type::B", ptr %[[B]], i32 0, i32 1
-// CHECK: call void asm sideeffect inteldialect "mov edx, dword ptr $0", "*m,~{edx},~{dirflag},~{fpsr},~{flags}"(ptr elementtype(i32) %[[X]])
+// CHECK: call void asm sideeffect inteldialect "mov edx, $0", "*m,~{edx},~{dirflag},~{fpsr},~{flags}"(ptr elementtype(i32) %[[X]])

llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp

 
 bool X86AsmParser::CreateMemForMSInlineAsm(
     unsigned SegReg, const MCExpr *Disp, unsigned BaseReg, unsigned IndexReg,
     unsigned Scale, SMLoc Start, SMLoc End, unsigned Size, StringRef Identifier,
     const InlineAsmIdentifierInfo &Info, OperandVector &Operands) {
   // If we found a decl other than a VarDecl, then assume it is a FuncDecl or
   // some other label reference.
   if (Info.isKind(InlineAsmIdentifierInfo::IK_Label)) {
-    // Insert an explicit size if the user didn't have one.
-    if (!Size) {
-      Size = getPointerWidth();
-      InstInfo->AsmRewrites->emplace_back(AOK_SizeDirective, Start,
-                                          /*Len=*/0, Size);
-    }
     // Create an absolute memory reference in order to match against
     // instructions taking a PC relative operand.
     Operands.push_back(X86Operand::CreateMem(getPointerWidth(), Disp, Start,
                                              End, Size, Identifier,
                                              Info.Label.Decl));
     return false;
   }
   // We either have a direct symbol reference, or an offset from a symbol.  The