[AArch64][ELF] Support R_AARCH64_AUTH_ABS64 static relocation

[kovdan01]

Summary

The patch adds parser, MCExpr, and emitter support for the authenticated
pointer auth relocation.

In assembly, this is expressed using:

.quad <symbol>@AUTH(<key>, <discriminator> [, addr])

For example:

.quad _g3@AUTH(ib, 1234, addr)

The optional 'addr' specifier represents whether the generated pointer
authentication code will also include address diversity (by blending the
address of the storage location of the relocated pointer with the
user-specified constant discriminator).

The @AUTH expression lowers to R_AARCH64_AUTH_ABS64 ELF relocation.

The signing schema is encoded in the place of relocation to be applied
as follows:

| 63                | 62 | 61:60 | 59:48 |  47:32        | 31:0   |
| ----------------- | -- | ----- | ----- | ------------- | ------ |
| address diversity | 0  | key   | 0     | discriminator | addend |

See the following for details:
https://github.com/ARM-software/abi-aa/blob/main/pauthabielf64/pauthabielf64.rst#static-relocations

Co-authored-by: Ahmed Bougacha <[e-mail]>
Co-authored-by: Peter Collingbourne <[e-mail]>

[peter.smith]

Will try and look at this next week (will be out of the office for a most of it so it could slip to the week after), happy to let others approve in my absence if they are happy with it.

[MaskRay]

lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

7522 ↗

(On Diff #545181)

Many of the error messages are untested.

7539 ↗

(On Diff #545181)

itostr requires including StringExtras.h. That said, you can use Twine(Discriminator) here.

Also, this error should be covered by a test.

7555 ↗

(On Diff #545181)

The error message is not tested.

I think a simple "expected ')'" is sufficient. The integrated assembler marks the column that an error occurs, so it's obvious that this message applies to @AUTH.

7561 ↗

(On Diff #545181)

nit: delete blank line

lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp

326 ↗

(On Diff #545181)

Nit

test/MC/AArch64/arm64-ptrauth-elf-reloc.s

1 ↗

(On Diff #545181)

Did you not use git format-patch -1 or git diff to create a diff?

This creates a directory under llvm-project, instead of using llvm/test/

1 ↗

(On Diff #545181)

llvm-mc doesn't need < %s. Just use %s

1 ↗

(On Diff #545181)

The test name should omit arm64- prefix, which is redundant for a file under MC/AArch64.

4 ↗

(On Diff #545181)

Prefer aarch64 for Linux target triples: https://nickdesaulniers.github.io/blog/2023/03/10/disambiguating-arm/

aarch64 (generic ELF) is better than *-linux as the former applies to other ELF OSes like *BSD.

5 ↗

(On Diff #545181)

llvm-readobj is quite verbose. Tabular output from llvm-readelf -S -r may look better. Use -x sectionname for content.

112 ↗

(On Diff #545181)

While here, consider making some _g* symbols defined or give them a local binding to add some variance.

114 ↗

(On Diff #545181)

A test involving more modifiers like a@PLT@AUTH(ib,0) may be interesting to add.

[MaskRay]

docs/PointerAuth.md

331 ↗

(On Diff #545181)

At the object file level, ...

"binary object file" is not a term.

333 ↗

(On Diff #545181)

ARM64_RELOC_AUTHENTICATED_POINTER is from Mach-O, but the sentence is written in the context of ELF. You need extra words to mean that this resembles ARM64_RELOC_AUTHENTICATED_POINTER from Mach-O.

344 ↗

(On Diff #545181)

delete trailing blank line

[kovdan01]

Address several review comments

[kovdan01]

@MaskRay Thanks for such a detailed review! I've uploaded a new "intermediate" version with all the fixes except enhancing tests (e.g. adding missing ones). Marked the corresponding comments as done, feel free to re-open them if further discussion is needed. Regarding tests enhancements - I'll upload the patch fixing that shortly.

docs/PointerAuth.md

333 ↗

(On Diff #545181)

ARM64_RELOC_AUTHENTICATED_POINTER is from Mach-O, but the sentence is written in the context of ELF. You need extra words to mean that this resembles ARM64_RELOC_AUTHENTICATED_POINTER from Mach-O.

The sentence was supposed to mention R_AARCH64_AUTH_ABS64, thanks for noticing this. I think we should not mention the MachO relocation in context of the patch: (a) the patch only adds support for the ELF reloc; (b) AFAIK, a different signing schema encoding is used for the MachO reloc. So, just replaced ARM64_RELOC_AUTHENTICATED_POINTER -> R_AARCH64_AUTH_ABS64 as initially intended.

test/MC/AArch64/arm64-ptrauth-elf-reloc.s

1 ↗

(On Diff #545181)

Did you not use git format-patch -1 or git diff to create a diff?

This creates a directory under llvm-project, instead of using llvm/test/

Thanks for bringing attention to this, fixed. It's quite strange though since I usually use git show HEAD -U999999 > mypatch.patch (as described here https://llvm.org/docs/Phabricator.html#requesting-a-review-via-the-web-interface) which works fine.

[kovdan01]

Fix various review comments:

• Add missing tests for error messages
• Enhance tests readability
• Minor nits

[kovdan01]

@MaskRay Fixed the issues you've mentioned. Would be glad to see your review on new version of the patch.

test/MC/AArch64/arm64-ptrauth-elf-reloc.s

114 ↗

(On Diff #545181)

Explicitly marked such combinations as unsupported.

[kovdan01]

lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

7555 ↗

(On Diff #545181)

I think a simple "expected ')'" is sufficient. The integrated assembler marks the column that an error occurs, so it's obvious that this message applies to @AUTH.

It makes sense. Deleted similar redundant info from other error messages as well.

test/MC/AArch64/arm64-ptrauth-elf-reloc.s

5 ↗

(On Diff #545181)

Thanks, llvm-readelf's output definitely looks better in our case

[peter.smith]

Not much to add to what MaskRay has already said. Some suggestions to improve error messages and comments.

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

7541

Similar error messages use out of range. Ideally we should give the permitted range in the error message.
integer discriminator <Discrimator> is out of range, [0, 65535] expected

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

338

I'm not sure if MC can easily generate a REL relocation for AArch64. IIRC REL format may occur in the dynamic case, for RELATIVE compression and REL format dynamic relocations (lld -z rel).

343

Worth saying what the range is in the error message? For example there are other error messages with fixup value out of range [-0xFFFF, 0xFFFF]"); For example:
"out of range addend <Value> in auth relocation. Permitted range [-2,147,483,648, -2,147,483,647]"

[kovdan01]

Fix issues mentioned by @pcc

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

7541

It makes sense, changed the message, thanks. I used hex values since they look nicer and more readable in this context.

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

338

I added a TODO for checking if such case is even possible. I think that the if statement should be kept since the ABI explicitly says that those bits are used for addend on platforms with rel.

Thanks for mentioning the dynamic case (lld -z rel). I'll check it, but it's out of scope of this patch so mark the comment as done. Feel free to re-open it if needed.

343

Fixed, thanks. I also used hex values here: although most people are familiar with decimal representation of these values, they are more messy than their hex variants.

[kovdan01]

@MaskRay @pcc I've addressed all the comments. Please let me know if there are some issues which must be fixed or the patch can be approved. Thanks!

[peter.smith]

In D156505#4578662, @kovdan01 wrote:

@MaskRay @pcc I've addressed all the comments. Please let me know if there are some issues which must be fixed or the patch can be approved. Thanks!

It looks OK on my side, MaskRay had more substantitive comments so I'm happy when he is.

FYI I'm not pcc, I'm psmith or peter.smith. Same first name as pcc which can be confusing!

[kovdan01]

In D156505#4579685, @peter.smith wrote:

FYI I'm not pcc, I'm psmith or peter.smith. Same first name as pcc which can be confusing!

Ah, my fault, sorry for that mistake.

[kovdan01]

Rebase to current mainline

[MaskRay]

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

201

delete blank line

llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.h

216

unneeded?

llvm/test/MC/AArch64/ptrauth-elf-reloc.s

94 ↗

(On Diff #549958)

llvm-mc has error recovery. You can test all errors in one llvm-mc invocation, instead of using many err*.s

95 ↗

(On Diff #549958)

continuation lines are indented by 2 by convention

97 ↗

(On Diff #549958)

Newer tests are recommended to test the line/column information like:

// ERR: :[[#@LINE+1]]:10: error: expected '('
.quad sym@AUTH)ia,42)

[kovdan01]

Fix issues mentioned by @MaskRay

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

201

Done

llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.h

216

This is needed for cast operation in adjustFixupValue in AArch64AsmBackend.cpp:341. But the check was not correct, fixed that. Decided to use a combination of isa + cast instead of a single dyn_cast since it results in a more elegant one-liner.

llvm/test/MC/AArch64/ptrauth-elf-reloc.s

94 ↗

(On Diff #549958)

Fixed, thanks

95 ↗

(On Diff #549958)

Fixed, thanks

97 ↗

(On Diff #549958)

Applied this, thanks

[MaskRay]

Being unable to reuse the generic AsmParser::parsePrimaryExpr if (!MAI.useParensForSymbolVariant()) makes me nervous, but I think this is probably fine.
However, I think we need some unary/binary operator tests like 1 + sym@AUTH(ia,42) + 1, sym@AUTH(ia,0) + sym@AUTH(ia,0). It's possible that many lead to errors.

llvm/docs/PointerAuth.md

308

This file is a Markdown. Single backquotes are more commonly used.

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

7541

Peter's suggestion does not contain a period, which is more conventional.

Other used formats include is not within [..., ...] (.subsections) and is not in [..., ...] (lld/ELF)

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

338

You can delete TODO.

AArch64ELFObjectWriter uses /*HasRelocationAddend*/ true.

You may use an assert instead.

343

Sorry for the bikeshedding, but I think out-of-range diagnostics don't usually contain a period.

Something like auth relocation addend <Value> out of range [...,...] may be better.

349

The two used-once variables can be removed.

351

delete blank line

418

I think this condition can be removed if we move custom code adjustFixupValue to this function. See the next comment.

428

We shouldn't have two conditions for FK_Data_8.

We probably should move the custom code from adjustFixupValue to here.

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

158

delete

llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.h

21

clang-format should move Casting.h before ErrorHandling.h

180

190

These annotations provide very little value. I think we discourage them for newer code to make classes more compact.

198

ditto

llvm/test/MC/AArch64/ptrauth-elf-reloc.s

94 ↗

(On Diff #549958)

Sorry that I didn't mention another point. When we have just one patch of negative tests, we can just wrap them with

.ifdef ERR
...
...
.endif

and then we can avoid invoking split-file.

You can grep def ERR in test/MC to find many newer tests I added.

97 ↗

(On Diff #549958)

[[#@LINE-77]] may not be a good choice. If we add more lines before the checks, the -77 part will need adjustment.

My original suggestion is

// ERR: :[[#@LINE+1]]:10: error: expected '('
.quad sym@AUTH)ia,42)

// ERR: :[[#@LINE+1]]:10: error: ...
.quad ...

1 ↗

(On Diff #550372)

To following the convention of test naming, this probably should be elf-reloc-ptrauth.s

6 ↗

(On Diff #550372)

ditto

actually, this line is so short that we should not use continuation

9 ↗

(On Diff #550372)

continuation lines are indented by 2 by convention

[kovdan01]

Fix some of @MaskRay's comment

[kovdan01]

TODO: add more unary/binary operator tests like 1 + sym@AUTH(ia,42) + 1, sym@AUTH(ia,0) + sym@AUTH(ia,0).

llvm/docs/PointerAuth.md

308

I agree with that, but double backquotes are already used in other places in this file.
I suggest to leave this 'as is' in context of current patch and submit a small subsequent patch changing double- to single backquote all over the file.

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

7541

Changed to integer discriminator <disc> out of range [..., ...] as such variant seems to be both compact and widely-used in lld. Thanks for providing the examples.

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

338

If I got your point correctly, we can even check that the value is exactly 0. With rela, the value must be exactly 0, not just a 32-bit integer. Please let me know if I got you right.

343

Got it, thanks. Fixed other error messages. This one seems to be obsolete when keeping the following in mind:

You can delete TODO.
AArch64ELFObjectWriter uses /*HasRelocationAddend*/ true.
You may use an assert instead.

349

Fixed

351

Fixed

418

This is more convenient, fixed, thanks.

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

158

Done

llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.h

21

Fixed, thanks. I avoided running clang-format on this particular file since it broke custom spacing before = sign in enum VariantKind below.

180

Done

190

OK, got it. I added them since the surrounding code was already using them, but I agree that they do not make much sense.

llvm/test/MC/AArch64/ptrauth-elf-reloc.s

94 ↗

(On Diff #549958)

Applied this approach, thanks!

97 ↗

(On Diff #549958)

It's a nice approach, fixed, thanks

1 ↗

(On Diff #550372)

Fixed

6 ↗

(On Diff #550372)

Fixed

9 ↗

(On Diff #550372)

Fixed

[MaskRay]

In D156505#4599128, @kovdan01 wrote:

TODO: add more unary/binary operator tests like 1 + sym@AUTH(ia,42) + 1, sym@AUTH(ia,0) + sym@AUTH(ia,0).

Yes, we should add the coverage, otherwise this looks good to me.

llvm/docs/PointerAuth.md

308

Adding double quotes than applying another patch changing double quotes to single quotes is not a good idea.
We can add single quotes directly.

The existing places can be fixed separately. I shall also mention that .rst is more commonly used and helps cross-doc links.

[kovdan01]

Propose additional unary/binary operator tests like 1 + sym@AUTH(ia,42) + 1, sym@AUTH(ia,0) + sym@AUTH(ia,0):

• Parsing assembly code
• Producing errors when emitting object file

To make the latter work properly, altered EvaluateSymbolicAdd. Without the change, incorrect relocations were emitted instead of producing an error. @MaskRay would be glad if you could look through this before landing since I consider these changes non-trivial.

[kovdan01]

llvm/docs/PointerAuth.md

308

OK, changed to single-quotes. After this lands, I'll send an NFC patch changing double-quotes in other places in this file

[MaskRay]

llvm/test/MC/AArch64/elf-reloc-ptrauth.s

87

By MCONLY you mean this is only used for -filetype=asm (default for llvm-mc)? I think using "MC" in this context is confusing.

ASMONLY may be better since -filetype=asm uses MCAsmStreamer, different from MCObjectStreamer used by -filetype=obj.

100

An subtraction expression test will be interesting as well.

The addition of two non-absolute symbols cannot be represented in the relocatable object file while the subtractions can often be represented.

[kovdan01]

Add a subtraction expression test

[kovdan01]

llvm/test/MC/AArch64/elf-reloc-ptrauth.s

87

Changed to ASMONLY, it suites the case better, thanks

100

Implemented a one. Left a TODO regarding subtraction of an AUTH and non-AUTH symbols. Currently we emit an error in such a case, but we might not want such behavior since there is no difference whether the symbol is AUTH or not when computing compile-time-known distance. Please let me know your thought regarding that.

llvm/docs/PointerAuth.md

 * [``llvm.ptrauth.blend``](#llvm-ptrauth-blend): The semantics of the blend
   operation are specified by the ABI.  In both the ELF PAuth ABI Extension and
   arm64e, it's a ``MOVK`` into the high 16 bits.  Consequently, this limits
   the width of the integer discriminator used in blends to 16 bits.
 * [``llvm.ptrauth.sign_generic``](#llvm-ptrauth-sign-generic): ``PACGA``
 * [``llvm.ptrauth.resign``](#llvm-ptrauth-resign): ``AUT*+PAC*``.  These are
   represented as a single pseudo-instruction in the backend to guarantee that
   the intermediate raw pointer value is not spilled and attackable.
+
+#### Assembly Representation
+
+At the assembly level,
+[Authenticated Relocations](#authenticated-global-relocation) are represented
+using the `@AUTH` modifier:
+
+```asm
+    .quad _target@AUTH(<key>,<discriminator>[,addr])
+```
+
+where:
+* `key` is the Armv8.3-A key identifier (`ia`, `ib`, `da`, `db`)
+* `discriminator` is the 16-bit unsigned discriminator value
+* `addr` signifies that the authenticated pointer is address-discriminated
+  (that is, that the relocation's target address is to be blended into the
+  `discriminator` before it is used in the sign operation.
+
+For example:
+```asm
+  _authenticated_reference_to_sym:
+    .quad _sym@AUTH(db,0)
+  _authenticated_reference_to_sym_addr_disc:
+    .quad _sym@AUTH(ia,12,addr)
+```
+
+#### ELF Object File Representation
+
+At the object file level,
+[Authenticated Relocations](#authenticated-global-relocation) are represented
+using the `R_AARCH64_AUTH_ABS64` relocation kind (with value `0xE100`).
+
+The signing schema is encoded in the place of relocation to be applied
+as follows:
+
+```
+| 63                | 62       | 61:60    | 59:48    |  47:32        | 31:0                |
+| ----------------- | -------- | -------- | -------- | ------------- | ------------------- |
+| address diversity | reserved | key      | reserved | discriminator | reserved for addend |
+```

llvm/include/llvm/BinaryFormat/ELFRelocs/AArch64.def

 // 0x404 and 0x405 are now R_AARCH64_TLS_IMPDEF1 and R_AARCH64_TLS_IMPDEF2
 // We follow GNU and define TLS_IMPDEF1 as TLS_DTPMOD64 and TLS_IMPDEF2 as
 // TLS_DTPREL64
 ELF_RELOC(R_AARCH64_TLS_DTPMOD64,                    0x404)
 ELF_RELOC(R_AARCH64_TLS_DTPREL64,                    0x405)
 ELF_RELOC(R_AARCH64_TLS_TPREL64,                     0x406)
 ELF_RELOC(R_AARCH64_TLSDESC,                         0x407)
 ELF_RELOC(R_AARCH64_IRELATIVE,                       0x408)
+ELF_RELOC(R_AARCH64_AUTH_ABS64,                      0xe100)
 
 // ELF_RELOC(R_AARCH64_P32_NONE,                         0)
 ELF_RELOC(R_AARCH64_P32_ABS32,                       0x001)
 ELF_RELOC(R_AARCH64_P32_ABS16,                       0x002)
 ELF_RELOC(R_AARCH64_P32_PREL32,                      0x003)
 ELF_RELOC(R_AARCH64_P32_PREL16,                      0x004)
 ELF_RELOC(R_AARCH64_P32_MOVW_UABS_G0,                0x005)
 ELF_RELOC(R_AARCH64_P32_MOVW_UABS_G0_NC,             0x006)

llvm/lib/MC/MCExpr.cpp

 ///
 /// \returns True on success, false if the result is not representable in an
 /// MCValue.
 
 /// NOTE: It is really important to have both the Asm and Layout arguments.
 /// They might look redundant, but this function can be used before layout
 /// is done (see the object streamer for example) and having the Asm argument
 /// lets us avoid relaxations early.
-static bool
-EvaluateSymbolicAdd(const MCAssembler *Asm, const MCAsmLayout *Layout,
-                    const SectionAddrMap *Addrs, bool InSet, const MCValue &LHS,
-                    const MCSymbolRefExpr *RHS_A, const MCSymbolRefExpr *RHS_B,
-                    int64_t RHS_Cst, MCValue &Res) {
+static bool EvaluateSymbolicAdd(const MCAssembler *Asm,
+                                const MCAsmLayout *Layout,
+                                const SectionAddrMap *Addrs, bool InSet,
+                                const MCValue &LHS, const MCValue &RHS,
+                                MCValue &Res) {
   // FIXME: This routine (and other evaluation parts) are *incredibly* sloppy
   // about dealing with modifiers. This will ultimately bite us, one day.
   const MCSymbolRefExpr *LHS_A = LHS.getSymA();
   const MCSymbolRefExpr *LHS_B = LHS.getSymB();
   int64_t LHS_Cst = LHS.getConstant();
 
+  const MCSymbolRefExpr *RHS_A = RHS.getSymA();
+  const MCSymbolRefExpr *RHS_B = RHS.getSymB();
+  int64_t RHS_Cst = RHS.getConstant();
+
+  if (LHS.getRefKind() != RHS.getRefKind())
+    return false;
+
   // Fold the result constant immediately.
   int64_t Result_Cst = LHS_Cst + RHS_Cst;
 
   assert((!Layout || Asm) &&
          "Must have an assembler object if layout is given!");
 
   // If we have a layout, we can fold resolved differences.
   if (Asm) {
case Binary: {
     // those first.
     if (!LHSValue.isAbsolute() || !RHSValue.isAbsolute()) {
       switch (ABE->getOpcode()) {
       default:
         return false;
       case MCBinaryExpr::Sub:
         // Negate RHS and add.
         // The cast avoids undefined behavior if the constant is INT64_MIN.
-        return EvaluateSymbolicAdd(Asm, Layout, Addrs, InSet, LHSValue,
-                                   RHSValue.getSymB(), RHSValue.getSymA(),
-                                   -(uint64_t)RHSValue.getConstant(), Res);
+        return EvaluateSymbolicAdd(
+            Asm, Layout, Addrs, InSet, LHSValue,
+            MCValue::get(RHSValue.getSymB(), RHSValue.getSymA(),
+                         -(uint64_t)RHSValue.getConstant(),
+                         RHSValue.getRefKind()),
+            Res);
 
       case MCBinaryExpr::Add:
-        return EvaluateSymbolicAdd(Asm, Layout, Addrs, InSet, LHSValue,
-                                   RHSValue.getSymA(), RHSValue.getSymB(),
-                                   RHSValue.getConstant(), Res);
+        return EvaluateSymbolicAdd(
+            Asm, Layout, Addrs, InSet, LHSValue,
+            MCValue::get(RHSValue.getSymA(), RHSValue.getSymB(),
+                         RHSValue.getConstant(), RHSValue.getRefKind()),
+            Res);
       }
     }
 
     // FIXME: We need target hooks for the evaluation. It may be limited in
     // width, and gas defines the result of comparisons differently from
     // Apple as.
     int64_t LHS = LHSValue.getConstant(), RHS = RHSValue.getConstant();
     int64_t Result = 0;

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

private:
   bool parseImmExpr(int64_t &Out);
   bool parseComma();
   bool parseRegisterInRange(unsigned &Out, unsigned Base, unsigned First,
                             unsigned Last);
 
   bool showMatchError(SMLoc Loc, unsigned ErrCode, uint64_t ErrorInfo,
                       OperandVector &Operands);
 
+  bool parseAuthExpr(const MCExpr *&Res, SMLoc &EndLoc);
+
   bool parseDirectiveArch(SMLoc L);
   bool parseDirectiveArchExtension(SMLoc L);
   bool parseDirectiveCPU(SMLoc L);
   bool parseDirectiveInst(SMLoc L);
 
   bool parseDirectiveTLSDescCall(SMLoc L);
 
   bool parseDirectiveLOH(StringRef LOH, SMLoc L);
#include "AArch64GenAsmMatcher.inc"
   bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
                      SMLoc &EndLoc) override;
   OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
                                         SMLoc &EndLoc) override;
   bool ParseDirective(AsmToken DirectiveID) override;
   unsigned validateTargetOperandClass(MCParsedAsmOperand &Op,
                                       unsigned Kind) override;
 
+  bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) override;
+
   static bool classifySymbolRef(const MCExpr *Expr,
                                 AArch64MCExpr::VariantKind &ELFRefKind,
                                 MCSymbolRefExpr::VariantKind &DarwinRefKind,
                                 int64_t &Addend);
 };
 
 /// AArch64Operand - Instances of this class represent a parsed AArch64 machine
 /// instruction.
if (Paired) {
         getTargetStreamer().emitARM64WinCFISaveAnyRegQ(EncodedReg, Offset);
     }
   } else {
     return Error(Start, "save_any_reg register must be x, q or d register");
   }
   return false;
 }
 
+bool AArch64AsmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) {
+  // Try @AUTH expressions: they're more complex than the usual symbol variants.
+  if (!parseAuthExpr(Res, EndLoc))
+    return false;
+  return getParser().parsePrimaryExpr(Res, EndLoc, nullptr);
+}
+
+///  parseAuthExpr
+///  ::= _sym@AUTH(ib,123[,addr])
+///  ::= (_sym + 5)@AUTH(ib,123[,addr])
+///  ::= (_sym - 5)@AUTH(ib,123[,addr])
+bool AArch64AsmParser::parseAuthExpr(const MCExpr *&Res, SMLoc &EndLoc) {
+  MCAsmParser &Parser = getParser();
+  MCContext &Ctx = getContext();
+
+  AsmToken Tok = Parser.getTok();
+
+  // Look for '_sym@AUTH' ...
+  if (Tok.is(AsmToken::Identifier) && Tok.getIdentifier().endswith("@AUTH")) {
+    StringRef SymName = Tok.getIdentifier().drop_back(strlen("@AUTH"));
+    if (SymName.find('@') != StringRef::npos)
+      return TokError(
+          "combination of @AUTH with other modifiers not supported");
+    Res = MCSymbolRefExpr::create(Ctx.getOrCreateSymbol(SymName), Ctx);
+
+    Parser.Lex(); // Eat the identifier.
+  } else {
+    // ... or look for a more complex symbol reference, such as ...
+    SmallVector<AsmToken, 6> Tokens;
+
+    // ... '"_long sym"@AUTH' ...
+    if (Tok.is(AsmToken::String))
+      Tokens.resize(2);
+    // ... or '(_sym + 5)@AUTH'.
+    else if (Tok.is(AsmToken::LParen))
+      Tokens.resize(6);
+    else
+      return true;
+
+    if (Parser.getLexer().peekTokens(Tokens) != Tokens.size())
+      return true;
+
+    // In either case, the expression ends with '@' 'AUTH'.
+    if (Tokens[Tokens.size() - 2].isNot(AsmToken::At) ||
+        Tokens[Tokens.size() - 1].isNot(AsmToken::Identifier) ||
+        Tokens[Tokens.size() - 1].getIdentifier() != "AUTH")
+      return true;
+
+    if (Tok.is(AsmToken::String)) {
+      StringRef SymName;
+      if (Parser.parseIdentifier(SymName))
+        return true;
+      Res = MCSymbolRefExpr::create(Ctx.getOrCreateSymbol(SymName), Ctx);
+    } else {
+      if (Parser.parsePrimaryExpr(Res, EndLoc, nullptr))
+        return true;
+    }
+
+    Parser.Lex(); // '@'
+    Parser.Lex(); // 'AUTH'
+  }
+
+  // At this point, we encountered "<id>@AUTH". There is no fallback anymore.
+  if (parseToken(AsmToken::LParen, "expected '('"))
+    return true;
+
+  if (Parser.getTok().isNot(AsmToken::Identifier))
+    return TokError("expected key name");
+
+  StringRef KeyStr = Parser.getTok().getIdentifier();
+  auto KeyIDOrNone = AArch64StringToPACKeyID(KeyStr);
+  if (!KeyIDOrNone)
+    return TokError("invalid key '" + KeyStr + "'");
+  Parser.Lex();
+
+  if (parseToken(AsmToken::Comma, "expected ','"))
+    return true;
+
+  if (Parser.getTok().isNot(AsmToken::Integer))
+    return TokError("expected integer discriminator");
+  int64_t Discriminator = Parser.getTok().getIntVal();
+
+  if (!isUInt<16>(Discriminator))
+    return TokError("integer discriminator " + Twine(Discriminator) +
+                    " out of range [0, 0xFFFF]");
+  Parser.Lex();
+
+  bool UseAddressDiversity = false;
+  if (Parser.getTok().is(AsmToken::Comma)) {
+    Parser.Lex();
+    if (Parser.getTok().isNot(AsmToken::Identifier) ||
+        Parser.getTok().getIdentifier() != "addr")
+      return TokError("expected 'addr'");
+    UseAddressDiversity = true;
+    Parser.Lex();
+  }
+
+  EndLoc = Parser.getTok().getEndLoc();
+  if (parseToken(AsmToken::RParen, "expected ')'"))
+    return true;
+
+  Res = AArch64AuthMCExpr::create(Res, Discriminator, *KeyIDOrNone,
+                                  UseAddressDiversity, Ctx);
+  return false;
+}
+
 bool
 AArch64AsmParser::classifySymbolRef(const MCExpr *Expr,
                                     AArch64MCExpr::VariantKind &ELFRefKind,
                                     MCSymbolRefExpr::VariantKind &DarwinRefKind,
                                     int64_t &Addend) {
   ELFRefKind = AArch64MCExpr::VK_INVALID;
   DarwinRefKind = MCSymbolRefExpr::VK_None;
   Addend = 0;

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

case AArch64::fixup_aarch64_pcrel_call26:
     return (Value >> 2) & 0x3ffffff;
   case FK_Data_1:
   case FK_Data_2:
   case FK_Data_4:
   case FK_Data_8:
   case FK_SecRel_2:
   case FK_SecRel_4:
     return Value;
   }
 }
 
 std::optional<MCFixupKind>
 AArch64AsmBackend::getFixupKind(StringRef Name) const {
   if (!TheTriple.isOSBinFormatELF())
     return std::nullopt;
 
   unsigned Type = llvm::StringSwitch<unsigned>(Name)
 #define ELF_RELOC(X, Y)  .Case(#X, Y)
 #include "llvm/BinaryFormat/ELFRelocs/AArch64.def"
 #undef ELF_RELOC
                       .Case("BFD_RELOC_NONE", ELF::R_AARCH64_NONE)
                       .Case("BFD_RELOC_16", ELF::R_AARCH64_ABS16)
                       .Case("BFD_RELOC_32", ELF::R_AARCH64_ABS32)
                       .Case("BFD_RELOC_64", ELF::R_AARCH64_ABS64)
                       .Default(-1u);
   if (Type == -1u)
     return std::nullopt;
   return static_cast<MCFixupKind>(FirstLiteralRelocationKind + Type);
 }
 
unsigned AArch64AsmBackend::getFixupKindContainereSizeInBytes(unsigned Kind) const {
   }
 }
 
 void AArch64AsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
                                    const MCValue &Target,
                                    MutableArrayRef<char> Data, uint64_t Value,
                                    bool IsResolved,
                                    const MCSubtargetInfo *STI) const {
+  if (Fixup.getTargetKind() == FK_Data_8 && TheTriple.isOSBinFormatELF()) {
+    auto RefKind = static_cast<AArch64MCExpr::VariantKind>(Target.getRefKind());
+    AArch64MCExpr::VariantKind SymLoc = AArch64MCExpr::getSymbolLoc(RefKind);
+    if (SymLoc == AArch64AuthMCExpr::VK_AUTH ||
+        SymLoc == AArch64AuthMCExpr::VK_AUTHADDR) {
+      assert(Value == 0);
+      const auto *Expr = cast<AArch64AuthMCExpr>(Fixup.getValue());
+      Value = (uint64_t(Expr->getDiscriminator()) << 32) |
+              (uint64_t(Expr->getKey()) << 60) |
+              (uint64_t(Expr->hasAddressDiversity()) << 63);
+    }
+  }
+
   if (!Value)
     return; // Doesn't change encoding.
   unsigned Kind = Fixup.getKind();
   if (Kind >= FirstLiteralRelocationKind)
     return;
   unsigned NumBytes = getFixupKindNumBytes(Kind);
   MCFixupKindInfo Info = getFixupKindInfo(Fixup.getKind());
   MCContext &Ctx = Asm.getContext();
   int64_t SignedValue = static_cast<int64_t>(Value);
   // Apply any target-specific value adjustments.
   Value = adjustFixupValue(Fixup, Target, Value, Ctx, TheTriple, IsResolved);
 
   // Shift the value into position.
   Value <<= Info.TargetOffset;
 
   unsigned Offset = Fixup.getOffset();
   assert(Offset + NumBytes <= Data.size() && "Invalid fixup offset!");
 
   // Used to point to big endian bytes.
   unsigned FulleSizeInBytes = getFixupKindContainereSizeInBytes(Fixup.getKind());
 

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

if (IsPCRel) {
     case FK_Data_4:
       return R_CLS(ABS32);
     case FK_Data_8:
       if (IsILP32) {
         Ctx.reportError(Fixup.getLoc(),
                         "ILP32 8 byte absolute data "
                         "relocation not supported (LP64 eqv: ABS64)");
         return ELF::R_AARCH64_NONE;
-      } else
+      } else {
+        if (RefKind == AArch64MCExpr::VK_AUTH ||
+            RefKind == AArch64MCExpr::VK_AUTHADDR)
+          return ELF::R_AARCH64_AUTH_ABS64;
         return ELF::R_AARCH64_ABS64;
+      }
     case AArch64::fixup_aarch64_add_imm12:
       if (RefKind == AArch64MCExpr::VK_DTPREL_HI12)
         return R_CLS(TLSLD_ADD_DTPREL_HI12);
       if (RefKind == AArch64MCExpr::VK_TPREL_HI12)
         return R_CLS(TLSLE_ADD_TPREL_HI12);
       if (RefKind == AArch64MCExpr::VK_DTPREL_LO12_NC)
         return R_CLS(TLSLD_ADD_DTPREL_LO12_NC);
       if (RefKind == AArch64MCExpr::VK_DTPREL_LO12)

llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.h

 //=--- AArch64MCExpr.h - AArch64 specific MC expression classes ---*- C++ -*-=//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file describes AArch64-specific MCExprs, used for modifiers like
 // ":lo12:" or ":gottprel_g1:".
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TARGET_AARCH64_MCTARGETDESC_AARCH64MCEXPR_H
 #define LLVM_LIB_TARGET_AARCH64_MCTARGETDESC_AARCH64MCEXPR_H
 
+#include "Utils/AArch64BaseInfo.h"
 #include "llvm/MC/MCExpr.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace llvm {
 
 class AArch64MCExpr : public MCTargetExpr {
 public:
   enum VariantKind {
     // Symbol locations specifying (roughly speaking) what calculation should be
     // performed to construct the final address for the relocated
     // symbol. E.g. direct, via the GOT, ...
     VK_ABS      = 0x001,
     VK_SABS     = 0x002,
     VK_PREL     = 0x003,
     VK_GOT      = 0x004,
     VK_DTPREL   = 0x005,
     VK_GOTTPREL = 0x006,
     VK_TPREL    = 0x007,
     VK_TLSDESC  = 0x008,
     VK_SECREL   = 0x009,
+    VK_AUTH     = 0x00a,
+    VK_AUTHADDR = 0x00b,
     VK_SymLocBits = 0x00f,
 
     // Variants specifying which part of the final address calculation is
     // used. E.g. the low 12 bits for an ADD/LDR, the middle 16 bits for a
     // MOVZ/MOVK.
     VK_PAGE     = 0x010,
     VK_PAGEOFF  = 0x020,
     VK_HI12     = 0x030,
enum VariantKind {
 
     VK_INVALID  = 0xfff
   };
 
 private:
   const MCExpr *Expr;
   const VariantKind Kind;
 
+protected:
   explicit AArch64MCExpr(const MCExpr *Expr, VariantKind Kind)
     : Expr(Expr), Kind(Kind) {}
 
 public:
   /// @name Construction
   /// @{
 
   static const AArch64MCExpr *create(const MCExpr *Expr, VariantKind Kind,
bool evaluateAsRelocatableImpl(MCValue &Res, const MCAsmLayout *Layout,
                                  const MCFixup *Fixup) const override;
 
   void fixELFSymbolsInTLSFixups(MCAssembler &Asm) const override;
 
   static bool classof(const MCExpr *E) {
     return E->getKind() == MCExpr::Target;
   }
 };
+
+class AArch64AuthMCExpr final : public AArch64MCExpr {
+  uint16_t Discriminator;
+  AArch64PACKey::ID Key;
+
+  explicit AArch64AuthMCExpr(const MCExpr *Expr, uint16_t Discriminator,
+                             AArch64PACKey::ID Key, bool HasAddressDiversity)
+      : AArch64MCExpr(Expr, HasAddressDiversity ? VK_AUTHADDR : VK_AUTH),
+        Discriminator(Discriminator), Key(Key) {}
+
+public:
+  static const AArch64AuthMCExpr *
+  create(const MCExpr *Expr, uint16_t Discriminator, AArch64PACKey::ID Key,
+         bool HasAddressDiversity, MCContext &Ctx);
+
+  AArch64PACKey::ID getKey() const { return Key; }
+  uint16_t getDiscriminator() const { return Discriminator; }
+  bool hasAddressDiversity() const { return getKind() == VK_AUTHADDR; }
+
+  void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const override;
+
+  void visitUsedExpr(MCStreamer &Streamer) const override;
+
+  MCFragment *findAssociatedFragment() const override;
+
+  bool evaluateAsRelocatableImpl(MCValue &Res, const MCAsmLayout *Layout,
+                                 const MCFixup *Fixup) const override;
+
+  static bool classof(const MCExpr *E) {
+    return isa<AArch64MCExpr>(E) && classof(cast<AArch64MCExpr>(E));
+  }
+
+  static bool classof(const AArch64MCExpr *E) {
+    return E->getKind() == VK_AUTH || E->getKind() == VK_AUTHADDR;
+  }
+};
 } // end namespace llvm
 
 #endif

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

void AArch64MCExpr::fixELFSymbolsInTLSFixups(MCAssembler &Asm) const {
   case VK_GOTTPREL:
   case VK_TPREL:
   case VK_TLSDESC:
     break;
   }
 
   fixELFSymbolsInTLSFixupsImpl(getSubExpr(), Asm);
 }
+
+const AArch64AuthMCExpr *AArch64AuthMCExpr::create(const MCExpr *Expr,
+                                                   uint16_t Discriminator,
+                                                   AArch64PACKey::ID Key,
+                                                   bool HasAddressDiversity,
+                                                   MCContext &Ctx) {
+  return new (Ctx)
+      AArch64AuthMCExpr(Expr, Discriminator, Key, HasAddressDiversity);
+}
+
+void AArch64AuthMCExpr::printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const {
+  bool WrapSubExprInParens = !isa<MCSymbolRefExpr>(getSubExpr());
+  if (WrapSubExprInParens)
+    OS << '(';
+  getSubExpr()->print(OS, MAI);
+  if (WrapSubExprInParens)
+    OS << ')';
+
+  OS << "@AUTH(" << AArch64PACKeyIDToString(Key) << ',' << Discriminator;
+  if (hasAddressDiversity())
+    OS << ",addr";
+  OS << ')';
+}
+
+void AArch64AuthMCExpr::visitUsedExpr(MCStreamer &Streamer) const {
+  Streamer.visitUsedExpr(*getSubExpr());
+}
+
+MCFragment *AArch64AuthMCExpr::findAssociatedFragment() const {
+  llvm_unreachable("FIXME: what goes here?");
+}
+
+bool AArch64AuthMCExpr::evaluateAsRelocatableImpl(MCValue &Res,
+                                                  const MCAsmLayout *Layout,
+                                                  const MCFixup *Fixup) const {
+  if (!getSubExpr()->evaluateAsRelocatable(Res, Layout, Fixup))
+    return false;
+
+  if (Res.getSymB())
+    report_fatal_error("Auth relocation can't reference two symbols");
+
+  Res = MCValue::get(Res.getSymA(), nullptr, Res.getConstant(), getKind());
+  return true;
+}

llvm/test/MC/AArch64/elf-reloc-ptrauth.s

+// RUN: llvm-mc -triple=aarch64 %s --defsym=ASMONLY=1 | FileCheck %s --check-prefix=ASM
+
+// RUN: llvm-mc -triple=aarch64 -filetype=obj %s | \
+// RUN:   llvm-readelf -S -r -x .test - | FileCheck %s --check-prefix=RELOC
+
+// RELOC: Relocation section '.rela.test' at offset 0x230 contains 8 entries:
+// RELOC-NEXT:  Offset Info Type Symbol's Value Symbol's Name + Addend
+// RELOC-NEXT: 0000000000000000 000000010000e100 R_AARCH64_AUTH_ABS64 0000000000000000 .helper + 0
+// RELOC-NEXT: 0000000000000010 000000080000e100 R_AARCH64_AUTH_ABS64 0000000000000000 _g1 + 0
+// RELOC-NEXT: 0000000000000020 000000090000e100 R_AARCH64_AUTH_ABS64 0000000000000000 _g2 + 0
+// RELOC-NEXT: 0000000000000030 0000000a0000e100 R_AARCH64_AUTH_ABS64 0000000000000000 _g3 + 0
+// RELOC-NEXT: 0000000000000040 0000000b0000e100 R_AARCH64_AUTH_ABS64 0000000000000000 _g4 + 7
+// RELOC-NEXT: 0000000000000050 0000000c0000e100 R_AARCH64_AUTH_ABS64 0000000000000000 _g5 - 3
+// RELOC-NEXT: 0000000000000060 000000020000e100 R_AARCH64_AUTH_ABS64 0000000000000000 _g 6 + 0
+// RELOC-NEXT: 0000000000000070 0000000d0000e100 R_AARCH64_AUTH_ABS64 0000000000000000 _g 7 + 7
+
+// RELOC: Hex dump of section '.test':
+//                VVVVVVVV addend, not needed for rela
+//                             VV reserved
+// RELOC-NEXT: 00 00000000 2a000000
+//                         ^^^^ discriminator
+//                               ^^ 0 no addr diversity 0 reserved 00 ia key 0000 reserved
+// RELOC-NEXT: 10 00000000 00000010
+//                         ^^^^ discriminator
+//                               ^^ 0 no addr diversity 0 reserved 01 ib key 0000 reserved
+// RELOC-NEXT: 20 00000000 050000a0
+//                         ^^^^ discriminator
+//                               ^^ 1    addr diversity 0 reserved 10 da key 0000 reserved
+// RELOC-NEXT: 30 00000000 ffff00b0
+//                         ^^^^ discriminator
+//                               ^^ 1    addr diversity 0 reserved 11 db key 0000 reserved
+// RELOC-NEXT: 40 00000000 00000000
+//                         ^^^^ discriminator
+//                               ^^ 0 no addr diversity 0 reserved 00 ia key 0000 reserved
+// RELOC-NEXT: 50 00000000 00de0010
+//                         ^^^^ discriminator
+//                               ^^ 0 no addr diversity 0 reserved 01 ib key 0000 reserved
+// RELOC-NEXT: 60 00000000 ff0000b0
+//                         ^^^^ discriminator
+//                               ^^ 1    addr diversity 0 reserved 11 db key 0000 reserved
+// RELOC-NEXT: 70 00000000 10000000
+//                         ^^^^ discriminator
+//                               ^^ 0 no addr diversity 0 reserved 00 ia key 0000 reserved
+// RELOC-NEXT: 80 04000000 00000000
+// Folded to constant 4 bytes difference between _g9 and _g8
+
+.section    .helper
+.local "_g 6"
+.type _g0, @function
+_g0:
+  ret
+.type _g8, @function
+_g8:
+  ret
+.type _g9, @function
+_g9:
+  ret
+
+.section  .test
+.p2align  3
+
+// ASM:          .xword _g0@AUTH(ia,42)
+.quad _g0@AUTH(ia,42)
+.quad 0
+
+// ASM:          .xword _g1@AUTH(ib,0)
+.quad _g1@AUTH(ib,0)
+.quad 0
+
+// ASM:          .xword _g2@AUTH(da,5,addr)
+.quad _g2@AUTH(da,5,addr)
+.quad 0
+
+// ASM:          .xword _g3@AUTH(db,65535,addr)
+.quad _g3@AUTH(db,0xffff,addr)
+.quad 0
+
+// ASM:          .xword (_g4+7)@AUTH(ia,0)
+.quad (_g4 + 7)@AUTH(ia,0)
+.quad 0
+
+// ASM:          .xword (_g5-3)@AUTH(ib,56832)
+.quad (_g5 - 3)@AUTH(ib,0xde00)
+.quad 0
+
+// ASM:          .xword "_g 6"@AUTH(db,255,addr)
+.quad "_g 6"@AUTH(db,0xff,addr)
+.quad 0
+
+// ASM:          .xword ("_g 7"+7)@AUTH(ia,16)
+.quad ("_g 7" + 7)@AUTH(ia,16)
+.quad 0
+
+// ASM:          .xword (_g9@AUTH(ia,42))-(_g8@AUTH(ia,42))
+.quad _g9@AUTH(ia,42) - _g8@AUTH(ia,42)
+.quad 0
+
+.ifdef ASMONLY
+
+// ASM:          .xword (_g10@AUTH(ia,42))+1
+.quad _g10@AUTH(ia,42) + 1
+
+// ASM:          .xword 1+(_g11@AUTH(ia,42))
+.quad 1 + _g11@AUTH(ia,42)
+
+// ASM:          .xword (1+(_g12@AUTH(ia,42)))+1
+.quad 1 + _g12@AUTH(ia,42) + 1
+
+// ASM:          .xword (_g13@AUTH(ia,42))+(_g14@AUTH(ia,42))
+.quad _g13@AUTH(ia,42) + _g14@AUTH(ia,42)
+
+// ASM:          .xword (_g9@AUTH(ia,42))-_g8
+.quad _g9@AUTH(ia,42) - _g8
+.quad 0
+
+.endif // ASMONLY
+
+.ifdef ERR
+// RUN: not llvm-mc -triple=aarch64 --defsym=ERR=1 %s 2>&1 | \
+// RUN:   FileCheck %s --check-prefix=ERR
+
+// ERR: :[[#@LINE+1]]:15: error: expected '('
+.quad sym@AUTH)ia,42)
+
+// ERR: :[[#@LINE+1]]:16: error: expected key name
+.quad sym@AUTH(42,42)
+
+// ERR: :[[#@LINE+1]]:16: error: invalid key 'ic'
+.quad sym@AUTH(ic,42)
+
+// ERR: :[[#@LINE+1]]:19: error: expected ','
+.quad sym@AUTH(ia 42)
+
+// ERR: :[[#@LINE+1]]:19: error: expected integer discriminator
+.quad sym@AUTH(ia,xxx)
+
+// ERR: :[[#@LINE+1]]:19: error: integer discriminator 65536 out of range [0, 0xFFFF]
+.quad sym@AUTH(ia,65536)
+
+// ERR: :[[#@LINE+1]]:22: error: expected 'addr'
+.quad sym@AUTH(ia,42,add)
+
+// ERR: :[[#@LINE+1]]:21: error: expected ')'
+.quad sym@AUTH(ia,42(
+
+// ERR: :[[#@LINE+1]]:7: error: combination of @AUTH with other modifiers not supported
+.quad sym@PLT@AUTH(ia,42)
+
+// ERR: :[[#@LINE+1]]:11: error: invalid variant 'AUTH@GOT'
+.quad sym@AUTH@GOT(ia,42)
+
+// ERR: :[[#@LINE+1]]:18: error: invalid variant 'TLSDESC@AUTH'
+.quad "long sym"@TLSDESC@AUTH(ia,42)
+
+// ERR: :[[#@LINE+1]]:18: error: invalid variant 'AUTH@PLT'
+.quad "long sym"@AUTH@PLT(ia,42)
+
+// ERR: :[[#@LINE+1]]:17: error: invalid variant 'GOT@AUTH'
+.quad (sym - 5)@GOT@AUTH(ia,42)
+
+// ERR: :[[#@LINE+1]]:17: error: invalid variant 'AUTH@TLSDESC'
+.quad (sym + 5)@AUTH@TLSDESC(ia,42)
+
+// ERR: :[[#@LINE+1]]:12: error: invalid variant 'AUTH'
+.quad +sym@AUTH(ia,42)
+
+.endif // ERR
+
+.ifdef ERROBJ
+// RUN: not llvm-mc -triple=aarch64 -filetype=obj --defsym=ERROBJ=1 %s -o /dev/null 2>&1 | \
+// RUN:   FileCheck %s --check-prefix=ERROBJ
+
+// ERROBJ: :[[#@LINE+1]]:7: error: expected relocatable expression
+.quad sym@AUTH(ia,42) + 1
+
+// ERROBJ: :[[#@LINE+1]]:7: error: expected relocatable expression
+.quad 1 + sym@AUTH(ia,42)
+
+// ERROBJ: :[[#@LINE+1]]:7: error: expected relocatable expression
+.quad 1 + sym@AUTH(ia,42) + 1
+
+// ERROBJ: :[[#@LINE+1]]:7: error: expected relocatable expression
+.quad sym@AUTH(ia,42) + sym@AUTH(ia,42)
+
+// TODO: do we really want to emit an error here? It might not be important
+// whether a symbol has an AUTH modifier or not since the compile-time computed
+// distance remains the same. Leave it in such state as for now since it
+// makes code simpler: subtraction of a non-AUTH symbol and of a constant
+// are handled identically.
+// ERROBJ: :[[#@LINE+1]]:7: error: expected relocatable expression
+.quad _g9@AUTH(ia,42) - _g8
+
+.endif // ERROBJ