[AArch64] Allow .variant_pcs before the symbol is registered

[MaskRay]

Summary

glibc sysdeps/aarch64/tst-vpcs-mod.S has something like:

.variant_pcs    vpcs_call
.global vpcs_call

This is supported by GNU as but leads to an error in MC. Use getOrCreateSymbol
to support a not-yet-registered symbol: call registerSymbol to ensure the
symbol exists even if there is no binding directive, to match GNU as.

While here, improve tests to check (1) a local symbol can get
STO_AARCH64_VARIANT_PCS (2) undefined .variant_pcs (3) an alias does not
inherit STO_AARCH64_VARIANT_PCS.

[MaskRay]

fix another gas incompatible with registerSymbol

[MaskRay]

add an alias test

[efriedma]

Please add a testcase where the symbol is local, for example:

.variant_pcs foo
foo:

(Not sure that's actually useful, but it's well-defined, as far as I can tell.)

[MaskRay]

Test local symbol

[efriedma]

LGTM

llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

if (parseToken(AsmToken::EndOfStatement,
     return true;
   getStreamer().emitCFIBKeyFrame();
   return false;
 }
 
 /// parseDirectiveVariantPCS
 /// ::= .variant_pcs symbolname
 bool AArch64AsmParser::parseDirectiveVariantPCS(SMLoc L) {
-  const AsmToken &Tok = getTok();
-  if (Tok.isNot(AsmToken::Identifier))
+  StringRef Name;
+  if (getParser().parseIdentifier(Name))
     return TokError("expected symbol name");
-
-  StringRef SymbolName = Tok.getIdentifier();
-
-  MCSymbol *Sym = getContext().lookupSymbol(SymbolName);
-  if (!Sym)
-    return TokError("unknown symbol");
-
-  Lex(); // Eat the symbol
-
   if (parseEOL())
     return true;
-  getTargetStreamer().emitDirectiveVariantPCS(Sym);
+  getTargetStreamer().emitDirectiveVariantPCS(
+      getContext().getOrCreateSymbol(Name));
   return false;
 }
 
 /// parseDirectiveSEHAllocStack
 /// ::= .seh_stackalloc
 bool AArch64AsmParser::parseDirectiveSEHAllocStack(SMLoc L) {
   int64_t Size;
   if (parseImmExpr(Size))

llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.cpp

AArch64ELFStreamer &AArch64TargetELFStreamer::getStreamer() {
   return static_cast<AArch64ELFStreamer &>(Streamer);
 }
 
 void AArch64TargetELFStreamer::emitInst(uint32_t Inst) {
   getStreamer().emitInst(Inst);
 }
 
 void AArch64TargetELFStreamer::emitDirectiveVariantPCS(MCSymbol *Symbol) {
+  getStreamer().getAssembler().registerSymbol(*Symbol);
   cast<MCSymbolELF>(Symbol)->setOther(ELF::STO_AARCH64_VARIANT_PCS);
 }
 
 MCTargetStreamer *
 llvm::createAArch64AsmTargetStreamer(MCStreamer &S, formatted_raw_ostream &OS,
                                      MCInstPrinter *InstPrint,
                                      bool isVerboseAsm) {
   return new AArch64TargetAsmStreamer(S, OS);

llvm/test/MC/AArch64/directive-variant_pcs-err.s

 // RUN: not llvm-mc -triple aarch64-unknown-none-eabi -filetype asm -o - %s 2>&1 | FileCheck %s
 
 // CHECK:      [[#@LINE+1]]:13: error: expected symbol name
 .variant_pcs
 
-// CHECK:      [[#@LINE+1]]:14: error: unknown symbol
-.variant_pcs foo
-
 .global foo
 // CHECK:      [[#@LINE+1]]:18: error: expected newline
 .variant_pcs foo bar

llvm/test/MC/AArch64/directive-variant_pcs.s

-// RUN: llvm-mc -triple aarch64-elf -filetype asm -o - %s | FileCheck %s
-// RUN: llvm-mc -triple aarch64-elf -filetype obj -o - %s \
-// RUN:   | llvm-readobj --symbols - | FileCheck %s --check-prefix=CHECK-ST_OTHER
+// RUN: llvm-mc -triple aarch64-elf -filetype asm %s | FileCheck %s --check-prefix=ASM
+// RUN: llvm-mc -triple aarch64-elf -filetype obj %s \
+// RUN:   | llvm-readelf -s - | FileCheck %s --check-prefix=OBJ
 
+// ASM:      .variant_pcs local
+// ASM-NEXT: local:
 .text
-.global foo
-.variant_pcs foo
-// CHECK: .variant_pcs foo
+.variant_pcs local
+local:
 
-// CHECK-ST_OTHER: Name: foo
-// CHECK-ST_OTHER: Other [ (0x80)
+/// Binding directive before .variant_pcs.
+// ASM:      .globl def1
+// ASM-NEXT: .variant_pcs def1
+// ASM-NEXT: def1:
+.global def1
+.variant_pcs def1
+def1:
+
+/// .variant_pcs before binding directive.
+// ASM:      .variant_pcs def2
+// ASM-NEXT: .weak def2
+// ASM-NEXT: def2:
+.variant_pcs def2
+.weak def2
+def2:
+
+.globl alias_def1
+.set alias_def1, def1
+
+// ASM:      .variant_pcs undef
+.variant_pcs undef
+
+// OBJ:      NOTYPE LOCAL  DEFAULT [VARIANT_PCS]  [[#]] local
+// OBJ-NEXT: NOTYPE GLOBAL DEFAULT [VARIANT_PCS]  [[#]] def1
+// OBJ-NEXT: NOTYPE WEAK   DEFAULT [VARIANT_PCS]  [[#]] def2
+// OBJ-NEXT: NOTYPE GLOBAL DEFAULT                [[#]] alias_def1
+// OBJ-NEXT: NOTYPE GLOBAL DEFAULT [VARIANT_PCS]  UND   undef