[AArch64] Emit the correct MCExpr relocations specifiers like VK_ABS_G0, etc

[mgrang]

Summary

D55896 and D56029 add support to emit fixups for :abs_g0: , :abs_g1_s: , etc.
This patch adds the necessary enums and MCExpr needed for lowering these.

[mgrang]

I am not sure what kind of tests I should add for this patch. This is one of the patches needed for adding SEH support to LLVM (D53540).

[efriedma]

You can write an MIR test, probably; check the assembly that gets emitted for an instruction like like "renamable $x0 = MOVKXi killed renamable $x0, target-flags(aarch64-g1, aarch64-nc) @a, 16".

[efriedma]

Also, you probably need to update AArch64InstrInfo::getSerializableBitmaskMachineOperandTargetFlags .

[rnk]

Still needs tests, right?

[mgrang]

In D56037#1346032, @rnk wrote:

Still needs tests, right?

Yes, I will add tests. Also I see that AArch64MCExpr::VK_NC is not set when AArch64II::MO_NC is set. Will fix this soon.

[mgrang]

lib/Target/AArch64/AArch64MCInstLower.cpp

230

The problem with setting VK_NC (if MO_NC is set) is that a lot of unit tests fail with the following assert:

        adrp    x0, "??_C@foo@"
        add     x0, x0, Invalid ELF symbol kind
UNREACHABLE executed at /local/mnt/workspace/mgrang/comm/src/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.cpp:78!

This is because a lot of flags like VK_PAGEOFF/VK_PAGE, etc also have to be set (like LowerSymbolELF does it). I am not sure that should be done in this patch.

Should I then restrict setting VK_NC only if one of MO_G3/MO_G2/MO_G1/MO_G0 and MO_NC are set?

[efriedma]

lib/Target/AArch64/AArch64MCInstLower.cpp

230

Ultimately, we should only form an AArch64MCExprs where getKind() returns a known kind (one of the enum values from the list in AArch64MCExpr); otherwise, it's not clear what relocation is being requested.

I'm fine guarding it with "if (RefFlags)" or something like that for now (so we VK_NONE for cases you aren't addressing with this patch). Please leave a FIXME; we should clean it up at some point for clarity, but it doesn't need to block this patch.

233

You can declare RefKind with type "auto" since it's obvious here.

[efriedma]

lib/Target/AArch64/AArch64MCInstLower.cpp

203

Formatting

[efriedma]

LGTM

lib/Target/AArch64/AArch64InstrInfo.cpp

 
 ArrayRef<std::pair<unsigned, const char *>>
 AArch64InstrInfo::getSerializableBitmaskMachineOperandTargetFlags() const {
   using namespace AArch64II;
 
   static const std::pair<unsigned, const char *> TargetFlags[] = {
       {MO_COFFSTUB, "aarch64-coffstub"},
       {MO_GOT, "aarch64-got"},   {MO_NC, "aarch64-nc"},
-      {MO_TLS, "aarch64-tls"},   {MO_DLLIMPORT, "aarch64-dllimport"}};
+      {MO_S, "aarch64-s"},       {MO_TLS, "aarch64-tls"},
+      {MO_DLLIMPORT, "aarch64-dllimport"}};
   return makeArrayRef(TargetFlags);
 }
 
 ArrayRef<std::pair<MachineMemOperand::Flags, const char *>>
 AArch64InstrInfo::getSerializableMachineMemOperandTargetFlags() const {
   static const std::pair<MachineMemOperand::Flags, const char *> TargetFlags[] =
       {{MOSuppressPair, "aarch64-suppress-pair"},
        {MOStridedAccess, "aarch64-strided-access"}};

lib/Target/AArch64/AArch64MCInstLower.cpp

MCOperand AArch64MCInstLower::lowerSymbolOperandELF(const MachineOperand &MO,
   RefKind = static_cast<AArch64MCExpr::VariantKind>(RefFlags);
   Expr = AArch64MCExpr::create(Expr, RefKind, Ctx);
 
   return MCOperand::createExpr(Expr);
 }
 
 MCOperand AArch64MCInstLower::lowerSymbolOperandCOFF(const MachineOperand &MO,
                                                      MCSymbol *Sym) const {
-  AArch64MCExpr::VariantKind RefKind = AArch64MCExpr::VK_NONE;
+  uint32_t RefFlags = 0;
+
   if (MO.getTargetFlags() & AArch64II::MO_TLS) {
     if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGEOFF)
-      RefKind = AArch64MCExpr::VK_SECREL_LO12;
+      RefFlags |= AArch64MCExpr::VK_SECREL_LO12;
     else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) ==
              AArch64II::MO_HI12)
-      RefKind = AArch64MCExpr::VK_SECREL_HI12;
+      RefFlags |= AArch64MCExpr::VK_SECREL_HI12;
+
+  } else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_S)
+    RefFlags |= AArch64MCExpr::VK_SABS;
+    else RefFlags |= AArch64MCExpr::VK_ABS;
+
+  bool MO_G = false;
+  if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G3) {
+    RefFlags |= AArch64MCExpr::VK_G3;
+    MO_G = true;
+  }
+  else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G2) {
+    RefFlags |= AArch64MCExpr::VK_G2;
+    MO_G = true;
+  }
+  else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G1) {
+    RefFlags |= AArch64MCExpr::VK_G1;
+    MO_G = true;
   }
+  else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G0) {
+    RefFlags |= AArch64MCExpr::VK_G0;
+    MO_G = true;
+  }
+
+  if (MO_G && MO.getTargetFlags() & AArch64II::MO_NC)
+    RefFlags |= AArch64MCExpr::VK_NC;
+
   const MCExpr *Expr =
       MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, Ctx);
   if (!MO.isJTI() && MO.getOffset())
     Expr = MCBinaryExpr::createAdd(
         Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);
+
+  AArch64MCExpr::VariantKind RefKind;
+  RefKind = static_cast<AArch64MCExpr::VariantKind>(RefFlags);
   Expr = AArch64MCExpr::create(Expr, RefKind, Ctx);
+
   return MCOperand::createExpr(Expr);
 }
 
 MCOperand AArch64MCInstLower::LowerSymbolOperand(const MachineOperand &MO,
                                                  MCSymbol *Sym) const {
   if (Printer.TM.getTargetTriple().isOSDarwin())
     return lowerSymbolOperandDarwin(MO, Sym);
   if (Printer.TM.getTargetTriple().isOSBinFormatCOFF())

lib/Target/AArch64/Utils/AArch64BaseInfo.h

enum TOF {
     /// exists (pre linker-relaxation), but on ELF the TLSModel used for the
     /// referee will affect interpretation.
     MO_TLS = 0x40,
 
     /// MO_DLLIMPORT - On a symbol operand, this represents that the reference
     /// to the symbol is for an import stub.  This is used for DLL import
     /// storage class indication on Windows.
     MO_DLLIMPORT = 0x80,
+
+    /// MO_S - Indicates that the bits of the symbol operand represented by
+    /// MO_G0 etc are signed.
+    MO_S = 0x100,
   };
 } // end namespace AArch64II
 
 } // end namespace llvm
 
 #endif