[X86] .code16: temporarily set Mode32Bit when matching an instruction with the data32 prefix

[MaskRay]

Summary

PR47632

This allows MC to match data32 ... as one instruction instead of two (data32 without insn + insn).

The compatibility with GNU as improves: data32 ljmp will be matched as ljmpl.
data32 lgdt 4(%eax) will be matched as lgdtl (prefixes: 0x67 0x66, instead
of 0x66 0x67).

GNU as supports many other data32 *w as *l. We currently just hard code
data32 callw and data32 ljmpw. Generalizing the suffix replacement is
tricky and requires a think about the "bwlq" appending suffix rules in MatchAndEmitATTInstruction.

[craig.topper]

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

3092

So unlike the previous code we're allowing plain "call" to be selected based on the forced mode?

[MaskRay]

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

3092

Now we match data32 something as one instruction instead of two.

The "call" special case can be dropped. Generalizing the suffix replacement is tricky and requires a think about the "bwlq" suffix rules on 3842.

[craig.topper]

LGTM

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

static const char OpPrecedence[] = {
   9, // IC_LPAREN
   0, // IC_IMM
   0  // IC_REGISTER
 };
 
 class X86AsmParser : public MCTargetAsmParser {
   ParseInstructionInfo *InstInfo;
   bool Code16GCC;
+  unsigned ForcedDataPrefix = 0;
 
   enum VEXEncoding {
     VEXEncoding_Default,
     VEXEncoding_VEX,
     VEXEncoding_VEX3,
     VEXEncoding_EVEX,
   };
 
if (is32BitMode())
       return Error(NameLoc, "redundant data32 prefix");
     if (is64BitMode())
       return Error(NameLoc, "'data32' is not supported in 64-bit mode");
     // Hack to 'data16' for the table lookup.
     PatchedName = "data16";
 
     if (getLexer().isNot(AsmToken::EndOfStatement)) {
       StringRef Next = Parser.getTok().getString();
-      // Parse data32 call as calll.
-      if (Next == "call" || Next == "callw") {
-        getLexer().Lex();
-        Name = "calll";
-        PatchedName = Name;
-        isPrefix = false;
-      }
-    }
-  }
+      // data32 effectively changes the instruction suffix.
+      // TODO Generalize.
+      if (Next == "callw")
+        Next = "calll";
+      if (Next == "ljmpw")
+        Next = "ljmpl";
+
+      Name = Next;
+      ForcedDataPrefix = X86::Mode32Bit;
 
   Operands.push_back(X86Operand::CreateToken(PatchedName, NameLoc));
 
   // Push the immediate if we extracted one from the mnemonic.
   if (ComparisonPredicate != ~0U && !isParsingIntelSyntax()) {
     const MCExpr *ImmOp = MCConstantExpr::create(ComparisonPredicate,
                                                  getParser().getContext());
     Operands.push_back(X86Operand::CreateImm(ImmOp, NameLoc, NameLoc));
bool X86AsmParser::MatchAndEmitATTInstruction(SMLoc IDLoc, unsigned &Opcode,
   if (ForcedDispEncoding == DispEncoding_Disp8)
     Prefixes |= X86::IP_USE_DISP8;
   else if (ForcedDispEncoding == DispEncoding_Disp32)
     Prefixes |= X86::IP_USE_DISP32;
 
   if (Prefixes)
     Inst.setFlags(Prefixes);
 
+  // In 16-bit mode, if data32 is specified, temporarily switch to 32-bit mode
+  // when matching the instruction.
+  if (ForcedDataPrefix == X86::Mode32Bit)
+    SwitchMode(X86::Mode32Bit);
   // First, try a direct match.
   FeatureBitset MissingFeatures;
   unsigned OriginalError = MatchInstruction(Operands, Inst, ErrorInfo,
                                             MissingFeatures, MatchingInlineAsm,
                                             isParsingIntelSyntax());
+  if (ForcedDataPrefix == X86::Mode32Bit) {
+    SwitchMode(X86::Mode16Bit);
+    ForcedDataPrefix = 0;
+  }
   switch (OriginalError) {
   default: llvm_unreachable("Unexpected match result!");
   case Match_Success:
     if (!MatchingInlineAsm && validateInstruction(Inst, Operands))
       return true;
     // Some instructions need post-processing to, for example, tweak which
     // encoding is selected. Loop on it while changes happen so the
     // individual transformations can chain off each other.

llvm/test/MC/X86/data-prefix-fail.s

 // RUN: not llvm-mc -triple x86_64-unknown-unknown --show-encoding %s 2> %t.err | FileCheck --check-prefix=64 %s
 // RUN: FileCheck --check-prefix=ERR64 < %t.err %s
 // RUN: not llvm-mc -triple i386-unknown-unknown --show-encoding %s 2> %t.err | FileCheck --check-prefix=32 %s
 // RUN: FileCheck --check-prefix=ERR32 < %t.err %s
 // RUN: not llvm-mc -triple i386-unknown-unknown-code16 --show-encoding %s 2> %t.err | FileCheck --check-prefix=16 %s
 // RUN: FileCheck --check-prefix=ERR16 < %t.err %s
 
 // ERR64: error: 'data32' is not supported in 64-bit mode
 // ERR32: error: redundant data32 prefix
-// 16: data32
-// 16: encoding: [0x66]
-// 16: lgdtw 0
-// 16: encoding: [0x0f,0x01,0x16,0x00,0x00]
+// 16: lgdtl 0
+// 16-SAME: encoding: [0x66,0x0f,0x01,0x16,0x00,0x00]
 data32 lgdt 0
 
 // 64: data16
 // 64: encoding: [0x66]
 // 64: lgdtq 0
 // 64: encoding: [0x0f,0x01,0x14,0x25,0x00,0x00,0x00,0x00]
 // 32: data16
 // 32: encoding: [0x66]

llvm/test/MC/X86/x86-16.s

 
 // CHECK: calll a
 // CHECK: calll a
 // CHECK: calll a
  calll a
 data32 call a
 data32 callw a
 
+// CHECK:      ljmpl $1, $2
+// CHECK-NEXT: ljmpl $1, $2
+data32 ljmp $1, $2
+data32 ljmpw $1, $2
+
 // CHECK: incb  %al # encoding: [0xfe,0xc0]
   incb %al
 
 // CHECK: incw  %ax # encoding: [0x40]
   incw %ax
 
 // CHECK: incl  %eax # encoding: [0x66,0x40]
   incl %eax

 // CHECK: lretl
 // CHECK: encoding: [0x66,0xcb]
 lretl
 
 // CHECK: data32
 // CHECK: encoding: [0x66]
 data32
 
-// CHECK: data32
-// CHECK: encoding: [0x66]
-// CHECK: lgdtw 4(%eax)
-// CHECK:  encoding: [0x67,0x0f,0x01,0x50,0x04]
+// CHECK: lgdtl 4(%eax)
+// CHECK-SAME:  encoding: [0x67,0x66,0x0f,0x01,0x50,0x04]
 data32 lgdt 4(%eax)
 
 // CHECK: wbnoinvd
 // CHECK:  encoding: [0xf3,0x0f,0x09]
 wbnoinvd
 
 // CHECK: umonitor %ax
 // CHECK:  encoding: [0xf3,0x0f,0xae,0xf0]