[llvm-ml] Imlement support for MASM's extern directive

[ayzhao]

Summary

The EXTERN keyword defines external symbols in MASM.

Credit goes to epastor@ for implementing most of the logic; I (ayzhao@)
added some bugfixes and tests.

[0]: https://docs.microsoft.com/en-us/cpp/assembler/masm/extern-masm?view=msvc-170

[ayzhao]

Make the extern.asm test more robust by declaring multiple symbols in one statement

[ayzhao]

Add tests for error messages

[ayzhao]

Actually add the extern_errors.asm test this time

[epastor]

llvm/test/tools/llvm-ml/extern.asm

5

If feasible, we should test that the type info works correctly too - possibly by checking that they work in the appropriate contexts and fail in the appropriate contexts?

Just off the top of my head (and I may have this wrong, I didn't check)... I think:

mov ebx, foo
mov bx, bar

should both work, but

mov bx, foo
mov bl, bar

should both fail due to size checking.

[ayzhao]

Add checks for type info.

[ayzhao]

use @LINE + 1 for consistency

llvm/lib/MC/MCParser/MasmParser.cpp

private:
   bool parseDirectiveMacro(StringRef Name, SMLoc NameLoc);
 
   bool parseDirectiveStruct(StringRef Directive, DirectiveKind DirKind,
                             StringRef Name, SMLoc NameLoc);
   bool parseDirectiveNestedStruct(StringRef Directive, DirectiveKind DirKind);
   bool parseDirectiveEnds(StringRef Name, SMLoc NameLoc);
   bool parseDirectiveNestedEnds();
 
+  bool parseDirectiveExtern();
+
   /// Parse a directive like ".globl" which accepts a single symbol (which
   /// should be a label or an external).
   bool parseDirectiveSymbolAttribute(MCSymbolAttr Attr);
 
   bool parseDirectiveComm(bool IsLocal); // ".comm" and ".lcomm"
 
   bool parseDirectiveComment(SMLoc DirectiveLoc); // "comment"
 
case DK_ENDS:
       return parseDirectiveNestedEnds();
     case DK_ALIGN:
       return parseDirectiveAlign();
     case DK_EVEN:
       return parseDirectiveEven();
     case DK_ORG:
       return parseDirectiveOrg();
     case DK_EXTERN:
-      eatToEndOfStatement(); // .extern is the default, ignore it.
-      return false;
+      return parseDirectiveExtern();
     case DK_PUBLIC:
       return parseDirectiveSymbolAttribute(MCSA_Global);
     case DK_COMM:
       return parseDirectiveComm(/*IsLocal=*/false);
     case DK_COMMENT:
       return parseDirectiveComment(IDLoc);
     case DK_INCLUDE:
       return parseDirectiveInclude();
while (true) {
     if (!parseOptionalToken(AsmToken::Comma))
       break;
     parseOptionalToken(AsmToken::EndOfStatement);
   }
 
   return false;
 }
 
+bool MasmParser::parseDirectiveExtern() {
+  // .extern is the default - but we still need to take any provided type info.
+  auto parseOp = [&]() -> bool {
+    StringRef Name;
+    SMLoc NameLoc = getTok().getLoc();
+    if (parseIdentifier(Name))
+      return Error(NameLoc, "expected name");
+    if (parseToken(AsmToken::Colon))
+      return true;
+
+    StringRef TypeName;
+    SMLoc TypeLoc = getTok().getLoc();
+    if (parseIdentifier(TypeName))
+      return Error(TypeLoc, "expected type");
+    AsmTypeInfo Type;
+    if (lookUpType(TypeName, Type))
+      return Error(TypeLoc, "unrecognized type");
+    KnownType[Name.lower()] = Type;
+
+    MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
+    Sym->setExternal(true);
+    getStreamer().emitSymbolAttribute(Sym, MCSA_Extern);
+
+    return false;
+  };
+
+  if (parseMany(parseOp))
+    return addErrorSuffix(" in directive 'extern'");
+  return false;
+}
+
 /// parseDirectiveSymbolAttribute
 ///  ::= { ".globl", ".weak", ... } [ identifier ( , identifier )* ]
 bool MasmParser::parseDirectiveSymbolAttribute(MCSymbolAttr Attr) {
   auto parseOp = [&]() -> bool {
     StringRef Name;
     SMLoc Loc = getTok().getLoc();
     if (parseIdentifier(Name))
       return Error(Loc, "expected identifier");

llvm/test/tools/llvm-ml/extern.asm

+; RUN: llvm-ml -m32 -filetype=s %s /Fo - | FileCheck %s --check-prefixes=CHECK,CHECK-32
+; RUN: llvm-ml -m64 -filetype=s %s /Fo - | FileCheck %s --check-prefixes=CHECK,CHECK-64
+
+extern foo : dword, bar : word
+; CHECK: .extern foo
+; CHECK: .extern bar
+
+.code
+mov ebx, foo
+; CHECK-32: mov ebx, dword ptr [foo]
+; CHECK-64: mov ebx, dword ptr [rip + foo]
+
+mov bx, bar
+; CHECK-32: mov bx, word ptr [bar]
+; CHECK-64: mov bx, word ptr [rip + bar]
+
+END

llvm/test/tools/llvm-ml/extern_errors.asm

+; RUN: not llvm-ml -filetype=s %s /Fo /dev/null 2>&1 | FileCheck %s --implicit-check-not=error:
+
+; CHECK: :[[# @LINE + 1]]:8: error: expected name in directive 'extern'
+extern 123
+
+; CHECK: :[[# @LINE + 1]]:14: error: expected type in directive 'extern'
+extern foo0 :
+
+; CHECK: :[[# @LINE + 1]]:15: error: unrecognized type in directive 'extern'
+extern bar0 : typedoesnotexist
+
+extern foo1 : dword, bar1 : word
+
+.code
+
+; CHECK: :[[# @LINE + 1]]:1: error: invalid operand for instruction
+mov bx, foo1
+
+; CHECK: :[[# @LINE + 1]]:1: error: invalid operand for instruction
+mov bl, bar1
+
+END

llvm/test/tools/llvm-ml/indirect_branch.asm

 ; RUN: llvm-ml -m64 -filetype=s %s /Fo - | FileCheck %s --check-prefixes=CHECK-64,CHECK
 ; RUN: llvm-ml -m32 -filetype=s %s /Fo - | FileCheck %s --check-prefixes=CHECK-32,CHECK
 
+ifdef rax
+  extern fn_ref_extern : qword
+else
+  extern fn_ref_extern : dword
+endif
+extern fn_ref_extern_word : word
+
 .data
 
 ifdef rax
   fn_ref qword 1
 else
   fn_ref dword 1
 endif
 

 je t15
 ; CHECK-LABEL: t15:
 ; CHECK: je t15
 
 t16:
 je [t16];
 ; CHECK-LABEL: t16:
 ; CHECK: je t16
+
+t17:
+call fn_ref_extern
+jmp fn_ref_extern
+; CHECK-LABEL: t17:
+; CHECK-64: call qword ptr [rip + fn_ref_extern]
+; CHECK-64: jmp qword ptr [rip + fn_ref_extern]
+; CHECK-32: call dword ptr [fn_ref_extern]
+; CHECK-32: jmp dword ptr [fn_ref_extern]
+
+t18:
+call [fn_ref_extern]
+jmp [fn_ref_extern]
+; CHECK-LABEL: t18:
+; CHECK-64: call qword ptr [rip + fn_ref_extern]
+; CHECK-64: jmp qword ptr [rip + fn_ref_extern]
+; CHECK-32: call dword ptr [fn_ref_extern]
+; CHECK-32: jmp dword ptr [fn_ref_extern]
+
+ifdef rax
+  t19:
+  call qword ptr [fn_ref_extern]
+  jmp qword ptr [fn_ref_extern]
+  ; CHECK-64-LABEL: t19:
+  ; CHECK-64: call qword ptr [rip + fn_ref_extern]
+  ; CHECK-64: jmp qword ptr [rip + fn_ref_extern]
+else
+  t19:
+  call dword ptr [fn_ref_extern]
+  jmp dword ptr [fn_ref_extern]
+  ; CHECK-32-LABEL: t19:
+  ; CHECK-32: call dword ptr [fn_ref_extern]
+  ; CHECK-32: jmp dword ptr [fn_ref_extern]
+
+  t20:
+  call fn_ref_extern_word
+  jmp fn_ref_extern_word
+  ; CHECK-32-LABEL: t20:
+  ; CHECK-32: call word ptr [fn_ref_extern_word]
+  ; CHECK-32-NEXT: jmp word ptr [fn_ref_extern_word]
+
+  t21:
+  call [fn_ref_extern_word]
+  jmp [fn_ref_extern_word]
+  ; CHECK-32-LABEL: t21:
+  ; CHECK-32: call word ptr [fn_ref_extern_word]
+  ; CHECK-32-NEXT: jmp word ptr [fn_ref_extern_word]
+
+  t22:
+  call word ptr [fn_ref_extern_word]
+  jmp word ptr [fn_ref_extern_word]
+  ; CHECK-32-LABEL: t22:
+  ; CHECK-32: call word ptr [fn_ref_extern_word]
+  ; CHECK-32-NEXT: jmp word ptr [fn_ref_extern_word]
+endif