[ms] [llvm-ml] Add support for "alias" directive

[epastor]

Summary

Support the "alias" directive.

Required support for emitWeakReference in MCWinCOFFStreamer.

[thakis]

Maybe have a test covering the parse error case too.

llvm/test/tools/llvm-ml/alias.test

16

What happens if you do alias <t5> = <t3> (ie an alias to an alias)?

[epastor]

llvm/test/tools/llvm-ml/alias.test

16

Interesting. Using ml64.exe and alias <t7> = <t4>, you get an alias to an alias:

008 00000000 SECT1  notype ()    External     | t2
009 00000000 UNDEF  notype       WeakExternal | t4
    Default index        8 Alias record
00B 00000000 UNDEF  notype       WeakExternal | t7
    Default index        9 Alias record

Using llvm-ml, you currently get a second weak default-null reference pointing directly to t2:

[ 3](sec  1)(fl 0x00)(ty  20)(scl   2) (nx 0) 0x00000001 t2
...
[ 7](sec  0)(fl 0x00)(ty   0)(scl  69) (nx 1) 0x00000000 t4
AUX indx 9 srch 3
[ 9](sec  1)(fl 0x00)(ty   0)(scl  69) (nx 0) 0x00000001 .weak.t4.default.t1
...
[17](sec  0)(fl 0x00)(ty   0)(scl  69) (nx 1) 0x00000000 t7
AUX indx 19 srch 3
[19](sec  1)(fl 0x00)(ty   0)(scl  69) (nx 0) 0x00000001 .weak.t7.default.t1

These will both alias back to t2, but it's unclear what the effects of this deviation are. What do the .weak .default symbols actually do? Can we guarantee these are equivalent?

[epastor]

Add testing for parse errors

Also, improve error messages

[epastor]

Rebase on parent

[epastor]

Fix error that discarded sections of alias name input

[epastor]

Rebase, and fix tests after D88305 changed how COFF aliases resolve

[epastor]

llvm/test/tools/llvm-ml/alias.test

16

D88305 resolved this by letting aliases for external symbols point directly to their targets. I've gone ahead and updated these tests to fix that - and also switched them over to llvm-readobj while I was at it, since it involves significantly less regex-hacking to make them match correctly.

[epastor]

Incorporate D88448 to fix external symbol resolution

[epastor]

Update tests for the new way procedures are handled

[epastor]

Rebase on parent

llvm/include/llvm/MC/MCWinCOFFStreamer.h

public:
   void EmitCOFFSymbolIndex(MCSymbol const *Symbol) override;
   void EmitCOFFSectionIndex(MCSymbol const *Symbol) override;
   void EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) override;
   void EmitCOFFImgRel32(MCSymbol const *Symbol, int64_t Offset) override;
   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override;
   void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                              unsigned ByteAlignment) override;
+  void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
   void emitZerofill(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
                     unsigned ByteAlignment, SMLoc Loc = SMLoc()) override;
   void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
                       unsigned ByteAlignment) override;
   void emitIdent(StringRef IdentString) override;
   void EmitWinEHHandlerData(SMLoc Loc) override;
   void emitCGProfileEntry(const MCSymbolRefExpr *From,
                           const MCSymbolRefExpr *To, uint64_t Count) override;

llvm/lib/MC/MCParser/COFFMasmParser.cpp

 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCParser/MCAsmLexer.h"
 #include "llvm/MC/MCParser/MCAsmParserExtension.h"
 #include "llvm/MC/MCParser/MCAsmParserUtils.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSymbolCOFF.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Support/SMLoc.h"
 #include <cassert>
 #include <cstdint>
 #include <limits>
 #include <utility>
 
 using namespace llvm;
bool ParseSectionSwitch(StringRef Section, unsigned Characteristics,
                           COFF::COMDATType Type);
 
   bool ParseDirectiveProc(StringRef, SMLoc);
   bool ParseDirectiveEndProc(StringRef, SMLoc);
   bool ParseDirectiveSegment(StringRef, SMLoc);
   bool ParseDirectiveSegmentEnd(StringRef, SMLoc);
   bool ParseDirectiveIncludelib(StringRef, SMLoc);
 
+  bool ParseDirectiveAlias(StringRef, SMLoc);
+
   bool ParseSEHDirectiveAllocStack(StringRef, SMLoc);
   bool ParseSEHDirectiveEndProlog(StringRef, SMLoc);
 
   bool IgnoreDirective(StringRef, SMLoc) {
     while (!getLexer().is(AsmToken::EndOfStatement)) {
       Lex();
     }
     return false;
void Initialize(MCAsmParser &Parser) override {
     // endm
     // exitm
     // goto
     // local
     // macro
     // purge
 
     // Miscellaneous directives
-    // alias
+    addDirectiveHandler<&COFFMasmParser::ParseDirectiveAlias>("alias");
     // assume
     // .fpo
     addDirectiveHandler<&COFFMasmParser::ParseDirectiveIncludelib>(
         "includelib");
     // option
     // popcontext
     // pushcontext
     // .safeseh
if (nextVal.equals_lower("far")) {
       Lex();
       return Error(nextLoc, "far procedure definitions not yet supported");
     } else if (nextVal.equals_lower("near")) {
       Lex();
       nextVal = getTok().getString();
       nextLoc = getTok().getLoc();
     }
   }
-  MCSymbol *Sym = getContext().getOrCreateSymbol(Label);
+  MCSymbolCOFF *Sym = cast<MCSymbolCOFF>(getContext().getOrCreateSymbol(Label));
 
-  // Define symbol as simple function
-  getStreamer().BeginCOFFSymbolDef(Sym);
-  getStreamer().EmitCOFFSymbolStorageClass(2);
-  getStreamer().EmitCOFFSymbolType(0x20);
-  getStreamer().EndCOFFSymbolDef();
+  // Define symbol as simple external function
+  Sym->setExternal(true);
+  Sym->setType(COFF::IMAGE_SYM_DTYPE_FUNCTION << COFF::SCT_COMPLEX_TYPE_SHIFT);
 
   bool Framed = false;
   if (getLexer().is(AsmToken::Identifier) &&
       getTok().getString().equals_lower("frame")) {
     Lex();
     Framed = true;
     getStreamer().EmitWinCFIStartProc(Sym, Loc);
   }
bool COFFMasmParser::ParseDirectiveEndProc(StringRef Directive, SMLoc Loc) {
   if (CurrentProcedureFramed) {
     getStreamer().EmitWinCFIEndProc(Loc);
   }
   CurrentProcedure = "";
   CurrentProcedureFramed = false;
   return false;
 }
 
+bool COFFMasmParser::ParseDirectiveAlias(StringRef Directive, SMLoc Loc) {
+  std::string AliasName, ActualName;
+  if (getTok().isNot(AsmToken::Less) ||
+      getParser().parseAngleBracketString(AliasName))
+    return Error(getTok().getLoc(), "expected <aliasName>");
+  if (getParser().parseToken(AsmToken::Equal))
+    return addErrorSuffix(" in " + Directive + " directive");
+  if (getTok().isNot(AsmToken::Less) ||
+      getParser().parseAngleBracketString(ActualName))
+    return Error(getTok().getLoc(), "expected <actualName>");
+
+  MCSymbol *Alias = getContext().getOrCreateSymbol(AliasName);
+  MCSymbol *Actual = getContext().getOrCreateSymbol(ActualName);
+
+  getStreamer().emitWeakReference(Alias, Actual);
+
+  return false;
+}
+
 bool COFFMasmParser::ParseSEHDirectiveAllocStack(StringRef Directive,
                                                  SMLoc Loc) {
   int64_t Size;
   SMLoc SizeLoc = getTok().getLoc();
   if (getParser().parseAbsoluteExpression(Size))
     return Error(SizeLoc, "expected integer size");
   if (Size % 8 != 0)
     return Error(SizeLoc, "stack size must be a multiple of 8");

llvm/lib/MC/MCWinCOFFStreamer.cpp

void MCWinCOFFStreamer::emitLocalCommonSymbol(MCSymbol *S, uint64_t Size,
   SwitchSection(Section);
   emitValueToAlignment(ByteAlignment, 0, 1, 0);
   emitLabel(Symbol);
   Symbol->setExternal(false);
   emitZeros(Size);
   PopSection();
 }
 
+void MCWinCOFFStreamer::emitWeakReference(MCSymbol *AliasS,
+                                          const MCSymbol *Symbol) {
+  auto *Alias = cast<MCSymbolCOFF>(AliasS);
+  emitSymbolAttribute(Alias, MCSA_Weak);
+
+  getAssembler().registerSymbol(*Symbol);
+  Alias->setVariableValue(MCSymbolRefExpr::create(
+      Symbol, MCSymbolRefExpr::VK_WEAKREF, getContext()));
+}
+
 void MCWinCOFFStreamer::emitZerofill(MCSection *Section, MCSymbol *Symbol,
                                      uint64_t Size, unsigned ByteAlignment,
                                      SMLoc Loc) {
   llvm_unreachable("not implemented");
 }
 
 void MCWinCOFFStreamer::emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
                                        uint64_t Size, unsigned ByteAlignment) {

llvm/test/tools/llvm-ml/alias.test

+; RUN: llvm-ml -filetype=obj %s | llvm-readobj --syms - | FileCheck %s
+
+.code
+
+proc1 PROC
+  ret
+proc1 ENDP
+
+proc2 PROC
+  ret
+proc2 ENDP
+
+alias <t1> = <proc1>
+; CHECK:      Symbol {
+; CHECK:        Name: t1
+; CHECK-NEXT:   Value: 0
+; CHECK-NEXT:   Section: IMAGE_SYM_UNDEFINED (0)
+; CHECK-NEXT:   BaseType: Null
+; CHECK-NEXT:   ComplexType: Null
+; CHECK-NEXT:   StorageClass: WeakExternal
+; CHECK-NEXT:   AuxSymbolCount: 1
+; CHECK-NEXT:   AuxWeakExternal {
+; CHECK-NEXT:     Linked: proc1
+; CHECK-NEXT:     Search: Alias
+; CHECK-NEXT:   }
+; CHECK-NEXT: }
+
+alias <t2> = <proc2>
+; CHECK:      Symbol {
+; CHECK:        Name: t2
+; CHECK-NEXT:   Value: 0
+; CHECK-NEXT:   Section: IMAGE_SYM_UNDEFINED (0)
+; CHECK-NEXT:   BaseType: Null
+; CHECK-NEXT:   ComplexType: Null
+; CHECK-NEXT:   StorageClass: WeakExternal
+; CHECK-NEXT:   AuxSymbolCount: 1
+; CHECK-NEXT:   AuxWeakExternal {
+; CHECK-NEXT:     Linked: proc2
+; CHECK-NEXT:     Search: Alias
+; CHECK-NEXT:   }
+; CHECK-NEXT: }
+
+alias <t3> = <foo>
+; CHECK:      Symbol {
+; CHECK:        Name: t3
+; CHECK-NEXT:   Value: 0
+; CHECK-NEXT:   Section: IMAGE_SYM_UNDEFINED (0)
+; CHECK-NEXT:   BaseType: Null
+; CHECK-NEXT:   ComplexType: Null
+; CHECK-NEXT:   StorageClass: WeakExternal
+; CHECK-NEXT:   AuxSymbolCount: 1
+; CHECK-NEXT:   AuxWeakExternal {
+; CHECK-NEXT:     Linked: foo
+; CHECK-NEXT:     Search: Alias
+; CHECK-NEXT:   }
+; CHECK-NEXT: }
+
+alias <t4> = <bar>
+bar PROC
+  ret
+bar ENDP
+
+; CHECK:      Symbol {
+; CHECK:        Name: t4
+; CHECK-NEXT:   Value: 0
+; CHECK-NEXT:   Section: IMAGE_SYM_UNDEFINED (0)
+; CHECK-NEXT:   BaseType: Null
+; CHECK-NEXT:   ComplexType: Null
+; CHECK-NEXT:   StorageClass: WeakExternal
+; CHECK-NEXT:   AuxSymbolCount: 1
+; CHECK-NEXT:   AuxWeakExternal {
+; CHECK-NEXT:     Linked: bar
+; CHECK-NEXT:     Search: Alias
+; CHECK-NEXT:   }
+; CHECK-NEXT: }
+
+alias <t5> = <t2>
+; CHECK:      Symbol {
+; CHECK:        Name: t5
+; CHECK-NEXT:   Value: 0
+; CHECK-NEXT:   Section: IMAGE_SYM_UNDEFINED (0)
+; CHECK-NEXT:   BaseType: Null
+; CHECK-NEXT:   ComplexType: Null
+; CHECK-NEXT:   StorageClass: WeakExternal
+; CHECK-NEXT:   AuxSymbolCount: 1
+; CHECK-NEXT:   AuxWeakExternal {
+; CHECK-NEXT:     Linked: t2
+; CHECK-NEXT:     Search: Alias
+; CHECK-NEXT:   }
+; CHECK-NEXT: }
+
+END

llvm/test/tools/llvm-ml/alias_errors.test

+; RUN: not llvm-ml -filetype=asm %s 2>&1 | FileCheck %s
+
+.code
+
+foo PROC
+  ret
+foo ENDP
+
+bar PROC
+  ret
+bar ENDP
+
+t1:
+alias foo = bar
+alias foo = <bar>
+alias <foo> = bar
+
+; CHECK: error: expected <aliasName>
+; CHECK: error: expected <aliasName>
+; CHECK: error: expected <actualName>
+
+t2:
+alias <foo> <bar>
+alias <foo>, <bar>
+
+; CHECK: error: unexpected token in alias directive
+; CHECK: error: unexpected token in alias directive
+
+t3:
+alias <foo = bar>
+alias <foo = bar
+
+; CHECK: error: unexpected token in alias directive
+; CHECK: error: expected <aliasName>
+
+END
 No newline at end of file