[X86] Support 'offset' when parsing intel syntax through llvm-mc or gcc inline assembly

[craig.topper]

Summary

Currently we only support the "offset" keyword during the first pass on MS style inline assembly. This means its unvailable to gcc inline assembly or just using llvm-mc. gas seems to support this when parsing intel syntax.

This patch adds support outside of the first pass of MS inline assembly. I left the first pass MS inline assembly code alone for now and added a fixme. I'm not sure if its correct or not. It looks to delete the 'offset' keyword as part of its rewrite, but that seems wrong.

[rnk]

This patch adds support outside of the first pass of MS inline assembly. I left the first pass MS inline assembly code alone for now and added a fixme. I'm not sure if its correct or not. It looks to delete the 'offset' keyword as part of its rewrite, but that seems wrong.

I think you're right, we probably don't need the rewrite if MC can just parse it directly after this change. I think it's fine to leave the rewrite for now, but we should remove it if we can in a followup.

[rnk]

lgtm

I meant to approve with the last comment, but I must have forgot or misclicked.

[craig.topper]

I think we need to finish D37461 instead.

lib/Target/X86/AsmParser/X86AsmParser.cpp

 std::unique_ptr<X86Operand> X86AsmParser::ParseIntelOperand() {
   MCAsmParser &Parser = getParser();
   const AsmToken &Tok = Parser.getTok();
   SMLoc Start, End;
 
   // FIXME: Offset operator
   // Should be handled as part of immediate expression, as other operators
   // Currently, only supported as a stand-alone operand
+  if (IdentifyIntelInlineAsmOperator(Tok.getString()) == IOK_OFFSET) {
+    // FIXME: Should MS inline assembly parsing really be handling this
+    // differently?
     if (isParsingInlineAsm())
-    if (IdentifyIntelInlineAsmOperator(Tok.getString()) == IOK_OFFSET)
       return ParseIntelOffsetOfOperator();
 
+    // Not parsing MS inline assembly. Parse this like '$' in AT&T.
+    Parser.Lex();
+    const MCExpr *Val;
+    // This is an immediate, so we should not parse a register. Do a precheck
+    // for '%' to supercede intra-register parse errors.
+    SMLoc L = Parser.getTok().getLoc();
+    if (getParser().parseExpression(Val, End) ||
+        check(isa<X86MCExpr>(Val), L, "expected immediate expression"))
+      return nullptr;
+    return X86Operand::CreateImm(Val, Start, End);
+  }
+
+
   // Parse optional Size directive.
   unsigned Size;
   if (ParseIntelMemoryOperandSize(Size))
     return nullptr;
   bool PtrInOperand = bool(Size);
 
   Start = Tok.getLoc();
 

test/MC/X86/intel-syntax-var-offset.s

+// RUN: llvm-mc %s -triple x86_64-unknown-unknown -show-encoding | FileCheck %s
+
+.intel_syntax noprefix
+// CHECK: movq $X, %rax
+// CHECK: encoding: [0x48,0xc7,0xc0,A,A,A,A]
+// CHECK: fixup A - offset: 3, value: X, kind: reloc_signed_4byte
+mov rax, offset X
+
+// CHECK: movq $X+1, %rax
+// CHECK: encoding: [0x48,0xc7,0xc0,A,A,A,A]
+// CHECK: fixup A - offset: 3, value: X+1, kind: reloc_signed_4byte
+mov rax, offset X + 1