[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

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

test/CodeGen/ms_this.cpp

25

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

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

41

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

[m_zuckerman]

test/CodeGen/ms_this.cpp

41

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

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

lib/Parse/ParseExprCXX.cpp

ParsedType Ty = Actions.getDestructorName(TildeLoc, *ClassName,
                                               SS, ObjectType,
                                               EnteringContext);
     if (!Ty)
       return true;
 
     Result.setDestructorName(TildeLoc, Ty, ClassNameLoc);
     return false;
   }
-  
+  if (Tok.is(tok::kw_this))
+    return false;
   Diag(Tok, diag::err_expected_unqualified_id)
     << getLangOpts().CPlusPlus;
   return true;
 }
 
 /// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
 /// memory in a typesafe manner and call constructors.
 ///
 /// This method is called to parse the new expression after the optional :: has

lib/Parse/ParseStmtAsm.cpp

if (IdTok.isNot(tok::identifier))
       break;
     ConsumeToken(); // Consume the period.
     IdentifierInfo *Id = Tok.getIdentifierInfo();
     ConsumeToken(); // Consume the identifier.
     unsigned OffsetUnused;
     Result = Actions.LookupInlineAsmVarDeclField(
         Result.get(), Id->getName(), OffsetUnused, Info, Tok.getLocation());
   }
+  if (Tok.is(tok::kw_this))
+    Result = ParseCXXThis();
 
   // Figure out how many tokens we are into LineToks.
   unsigned LineIndex = 0;
   if (Tok.is(EndOfStream)) {
     LineIndex = LineToks.size() - 2;
   } else {
     while (LineToks[LineIndex].getLocation() != Tok.getLocation()) {
       LineIndex++;

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();
+};
+
+struct s {
+  void func() {
+    __asm mov eax, [this]
+    //CHECK: %this.addr = alloca %struct.s*
+  }
+} f3;
+
+void t2::runc() {
+  double num = 0;
+  __asm {
+       mov rax,[this]
+      //CHECK :%this.addr = alloca %class.t2*
+       mov rbx,[rax]
+       mov num, rbx
+     };
+}
+
+void t1::runc() {
+  double num = 0;
+  __asm {
+       mov rax,[this]
+      //CHECK :%this.addr = alloca %class.t1*
+       mov rbx,[rax]
+       mov num, rbx
+     };
+}
+
+int main() {
+  f3.func();
+  return 0;
+}