[X86][MS-InlineAsm] Use exact conditions to recognize MS global variables

[pengfei]

Summary

D115225 tried to roll back the effects on symbols of MS inline asm
introduced by D113096. But the combination of the conditions cannot
match all the changes. As a result, there are still fails after the
patch.

This patch fixes the problem by checking the exact conditions for MS
global variables, i.e., variable (by FrontendSize != 0) + non rip/eip
(by DefaultBaseReg == 0), so that we can fully roll back for D113096.

[skan]

Thank you for the fix! LGTM

[pengfei]

In D116090#3205828, @skan wrote:

Thank you for the fix! LGTM

Thanks for the review!

[pengfei]

There are several buildbot fail. Need to investigate it.

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

int bar() {
   // CHECK-LABEL: _bar:
   __asm jmp k;
   // CHECK:     jmp     _k
 }
 
 int baz() {
   // CHECK-LABEL: _baz:
   __asm mov eax, k;
-  // CHECK: movl    k, %eax
+  // CHECK: movl    _k, %eax
   __asm mov eax, kptr;
   // CHECK: movl    _kptr, %eax
 }
 
 // Test that this asm blob doesn't require more registers than available.  This
 // has to be an LLVM code generation test.
 
 void __declspec(naked) naked() {

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

if (Info.isKind(InlineAsmIdentifierInfo::IK_Var)) {
     FrontendSize = Info.Var.Type * 8;
     Decl = Info.Var.Decl;
     IsGlobalLV = Info.Var.IsGlobalLV;
   }
   // It is widely common for MS InlineAsm to use a global variable and one/two
   // registers in a mmory expression, and though unaccessible via rip/eip.
   if (IsGlobalLV && (BaseReg || IndexReg)) {
     Operands.push_back(X86Operand::CreateMem(getPointerWidth(), Disp, Start,
-                                             End, Size, Identifier, Decl));
+                                             End, Size, Identifier, Decl,
+                                             FrontendSize));
     return false;
   }
   // Otherwise, we set the base register to a non-zero value
   // if we don't know the actual value at this time.  This is necessary to
   // get the matching correct in some cases.
   BaseReg = BaseReg ? BaseReg : 1;
   Operands.push_back(X86Operand::CreateMem(
       getPointerWidth(), SegReg, Disp, BaseReg, IndexReg, Scale, Start, End,

llvm/lib/Target/X86/AsmParser/X86Operand.h

bool isImmUnsignedi8() const {
     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
     if (!CE) return true;
     return isImmUnsignedi8Value(CE->getValue());
   }
 
   bool isOffsetOfLocal() const override { return isImm() && Imm.LocalRef; }
 
   bool isMemPlaceholder(const MCInstrDesc &Desc) const override {
-    // Add more restrictions to avoid the use of global symbols. This helps
-    // with reducing the code size.
-    return !Desc.isRematerializable() && !Desc.isCall() && isMem() &&
-           !Mem.BaseReg && !Mem.IndexReg;
+    // Only MS InlineAsm uses global variables with registers rather than
+    // rip/eip.
+    return isMem() && !Mem.DefaultBaseReg && Mem.FrontendSize;
   }
 
   bool needAddressOf() const override { return AddressOf; }
 
   bool isMem() const override { return Kind == Memory; }
   bool isMemUnsized() const {
     return Kind == Memory && Mem.Size == 0;
   }