This is an archive of the discontinued LLVM Phabricator instance.

Differential D57061

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

Authored by craig.topper on Jan 22 2019, 11:35 AM.

Details

Reviewers
rnk
echristo
efriedma
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.

Diff Detail

Event Timeline

craig.topper created this revision.Jan 22 2019, 11:35 AM
rnk added a comment.Jan 22 2019, 11:47 AM

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 accepted this revision.Jan 23 2019, 11:46 AM

lgtm

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

This revision is now accepted and ready to land.Jan 23 2019, 11:46 AM
craig.topper abandoned this revision.Jan 23 2019, 12:26 PM

I think we need to finish D37461 instead.

Revision Contents

PathSize
lib/
Target/
X86/
AsmParser/
19 lines
test/
MC/
X86/
12 lines

Diff 182950

lib/Target/X86/AsmParser/X86AsmParser.cpp

Show First 20 Lines • Show All 1,828 Lines • ▼ Show 20 Lines
std::unique_ptr<X86Operand> X86AsmParser::ParseIntelOperand() { std::unique_ptr<X86Operand> X86AsmParser::ParseIntelOperand() {
MCAsmParser &Parser = getParser(); MCAsmParser &Parser = getParser();
const AsmToken &Tok = Parser.getTok(); const AsmToken &Tok = Parser.getTok();
SMLoc Start, End; SMLoc Start, End;
// FIXME: Offset operator // FIXME: Offset operator
// Should be handled as part of immediate expression, as other operators // Should be handled as part of immediate expression, as other operators
// Currently, only supported as a stand-alone operand // 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 (isParsingInlineAsm())
if (IdentifyIntelInlineAsmOperator(Tok.getString()) == IOK_OFFSET)
return ParseIntelOffsetOfOperator(); 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. // Parse optional Size directive.
unsigned Size; unsigned Size;
if (ParseIntelMemoryOperandSize(Size)) if (ParseIntelMemoryOperandSize(Size))
return nullptr; return nullptr;
bool PtrInOperand = bool(Size); bool PtrInOperand = bool(Size);
Start = Tok.getLoc(); Start = Tok.getLoc();
▲ Show 20 Lines • Show All 1,638 Lines • Show Last 20 Lines

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

  • This file was added.
// 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