[Microsoft][C++] Clang doesn't support a use of "this" pointer inside inline asm

[m_zuckerman]

Summary

Clang doesn’t support a use of “this” pointer inside inline asm.
When I tried to compile a class or a struct (see example) with an inline asm that contains "this" pointer.
Clang returns with an error.
This patch fixes that.

error: expected unqualified-id
For example:

struct A {
  void f() {
    __asm mov eax, this
    // error: expected unqualified-id
  }
};

[rnk]

lib/Parse/ParseExprCXX.cpp

2567–2568 ↗

(On Diff #41519)

Surely this breaks the contract of ParseUnqualifiedId, which should not return success if called on a 'this' token.

test/CodeGen/ms_this.cpp

25 ↗

(On Diff #41519)

I think FileCheck will insist that this is spelled without a space before the colon.

It would also be better to test that %this.addr is used as an argument to an asm blob, something like this:

// CHECK: call void asm sideeffect {{.*}}%this.addr

[m_zuckerman]

ping

[rnk]

lib/Parse/ParseExprCXX.cpp

2567–2569 ↗

(On Diff #41612)

I think you want to teach ParseMSAsmIdentifier to check for kw_this before calling ParseUnqualifiedId. That would make it consistent with the primary-expression production in the comments above ParseCastExpression.

[rnk]

lgtm

test/CodeGen/ms_this.cpp

40 ↗

(On Diff #42659)

Is this correct? Shouldn't "this" be $1 or something?

[m_zuckerman]

test/CodeGen/ms_this.cpp

40 ↗

(On Diff #42659)

This is depend on which mode we use 32 or 64. I changed it to be consistent with other class .

cfe/trunk/lib/CodeGen/CGStmt.cpp

if (InputExpr->EvaluateAsInt(Result, getContext()))
       return llvm::ConstantInt::get(getLLVMContext(), Result);
     assert(!Info.requiresImmediateConstant() &&
            "Required-immediate inlineasm arg isn't constant?");
   }
 
   if (Info.allowsRegister() || !Info.allowsMemory())
     if (CodeGenFunction::hasScalarEvaluationKind(InputExpr->getType()))
       return EmitScalarExpr(InputExpr);
-
+  if (InputExpr->getStmtClass() == Expr::CXXThisExprClass)
+    return EmitScalarExpr(InputExpr);
   InputExpr = InputExpr->IgnoreParenNoopCasts(getContext());
   LValue Dest = EmitLValue(InputExpr);
   return EmitAsmInputLValue(Info, Dest, InputExpr->getType(), ConstraintStr,
                             InputExpr->getExprLoc());
 }
 
 /// getAsmSrcLocInfo - Return the !srcloc metadata node to attach to an inline
 /// asm call instruction.  The !srcloc MDNode contains a list of constant

cfe/trunk/lib/Parse/ParseStmtAsm.cpp

ExprResult Parser::ParseMSAsmIdentifier(llvm::SmallVectorImpl<Token> &LineToks,
   CXXScopeSpec SS;
   if (getLangOpts().CPlusPlus) {
     ParseOptionalCXXScopeSpecifier(SS, ParsedType(), /*EnteringContext=*/false);
   }
 
   // Require an identifier here.
   SourceLocation TemplateKWLoc;
   UnqualifiedId Id;
-  bool Invalid =
+  bool Invalid = true;
+  ExprResult Result;
+  if (Tok.is(tok::kw_this)) {
+    Result = ParseCXXThis();
+    Invalid = false;
+  } else {
+    Invalid =
         ParseUnqualifiedId(SS,
                            /*EnteringContext=*/false,
                            /*AllowDestructorName=*/false,
                            /*AllowConstructorName=*/false,
                            /*ObjectType=*/ParsedType(), TemplateKWLoc, Id);
-
     // Perform the lookup.
-  ExprResult Result = Actions.LookupInlineAsmIdentifier(
-      SS, TemplateKWLoc, Id, Info, IsUnevaluatedContext);
-
+    Result = Actions.LookupInlineAsmIdentifier(SS, TemplateKWLoc, Id, Info,
+                                               IsUnevaluatedContext);
+  }
   // While the next two tokens are 'period' 'identifier', repeatedly parse it as
   // a field access. We have to avoid consuming assembler directives that look
   // like '.' 'else'.
   while (Result.isUsable() && Tok.is(tok::period)) {
     Token IdTok = PP.LookAhead(0);
     if (IdTok.isNot(tok::identifier))
       break;
     ConsumeToken(); // Consume the period.

cfe/trunk/test/CodeGen/ms_this.cpp

+// RUN: %clang_cc1 -fasm-blocks -emit-llvm %s -o - | FileCheck %s
+class t1 {
+public:
+  double a;
+  void runc();
+};
+
+class t2 {
+public:
+  double a;
+  void runc();
+};
+
+void t2::runc() {
+  double num = 0;
+  __asm {
+      mov rax,[this]
+      //CHECK: %this.addr = alloca %class.t2*
+      //CHECK: call void asm sideeffect inteldialect "mov rax,qword ptr $1{{.*}}%class.t2* %this1
+      mov rbx,[rax]
+      mov num, rbx
+     };
+}
+
+void t1::runc() {
+  double num = 0;
+  __asm {
+       mov rax,[this]
+      //CHECK: %this.addr = alloca %class.t1*
+      //CHECK: call void asm sideeffect inteldialect "mov rax,qword ptr $1{{.*}}%class.t1* %this1
+        mov rbx,[rax]
+        mov num, rbx
+     };
+}
+
+struct s {
+  int a;
+  void func() {
+    __asm mov rax, [this]
+    //CHECK: %this.addr = alloca %struct.s*
+    //CHECK: call void asm sideeffect inteldialect "mov rax, qword ptr $0{{.*}}%struct.s* %this1
+  }
+} f3;
+
+int main() {
+  f3.func();
+  f3.a=1;
+  return 0;
+}