[AArch64] [Windows] Misc fixes for llvm-readobj -unwind.

[efriedma]

Summary

Use getImageBase() helper to compute the image base. Fix various offsets/addresses/masks so they're actually correct.

This allows decoding unwind info from DLLs, and from object files containing multiple functions.

[ssijaric]

LGTM

include/llvm/Support/ARMWinEH.h

uint8_t Condition() const {
     return ((ES & 0x00f00000) >> 20);
   }
 
   // Different implementations for ARM and AArch64.
   uint8_t EpilogueStartIndexARM() const {
     return ((ES & 0xff000000) >> 24);
   }
 
-  uint8_t EpilogueStartIndexAArch64() const {
+  uint16_t EpilogueStartIndexAArch64() const {
     return ((ES & 0xffc00000) >> 22);
   }
 };
 
 struct ExceptionDataRecord;
 inline size_t HeaderWords(const ExceptionDataRecord &XR);
 
 struct ExceptionDataRecord {
struct ExceptionDataRecord {
   uint32_t ExceptionHandlerParameter() const {
     assert(X() && "Exception Handler RVA is only valid if the X bit is set");
     return Data[HeaderWords(*this) + EpilogueCount() + CodeWords() + 1];
   }
 };
 
 inline size_t HeaderWords(const ExceptionDataRecord &XR) {
   if (XR.isAArch64)
-    return (XR.Data[0] & 0xffc0000) ? 1 : 2;
+    return (XR.Data[0] & 0xffc00000) ? 1 : 2;
   return (XR.Data[0] & 0xff800000) ? 1 : 2;
 }
 }
 }
 }
 
 #endif

tools/llvm-readobj/ARMWinEHPrinter.cpp

void Decoder::decodeOpcodes(ArrayRef<uint8_t> Opcodes, unsigned Offset,
   assert((!Prologue || Offset == 0) && "prologue should always use offset 0");
   const RingEntry* DecodeRing = isAArch64 ? Ring64 : Ring;
   bool Terminated = false;
   for (unsigned OI = Offset, OE = Opcodes.size(); !Terminated && OI < OE; ) {
     for (unsigned DI = 0;; ++DI) {
       if ((isAArch64 && (DI >= array_lengthof(Ring64))) ||
           (!isAArch64 && (DI >= array_lengthof(Ring)))) {
         SW.startLine() << format("0x%02x                ; Bad opcode!\n",
-                                 Opcodes.data()[Offset]);
+                                 Opcodes.data()[OI]);
         ++OI;
         break;
       }
 
       if ((Opcodes[OI] & DecodeRing[DI].Mask) == DecodeRing[DI].Value) {
         if (OI + DecodeRing[DI].Length > OE) {
           SW.startLine() << format("Opcode 0x%02x goes past the unwind data\n",
                                     Opcodes[OI]);
if (XData.E()) {
     for (const EpilogueScope ES : EpilogueScopes) {
       DictScope ESES(SW, "EpilogueScope");
       SW.printNumber("StartOffset", ES.EpilogueStartOffset());
       if (!isAArch64)
         SW.printNumber("Condition", ES.Condition());
       SW.printNumber("EpilogueStartIndex",
                      isAArch64 ? ES.EpilogueStartIndexAArch64()
                                : ES.EpilogueStartIndexARM());
+      if (ES.ES & ~0xffc3ffff)
+        SW.printNumber("ReservedBits", (ES.ES >> 18) & 0xF);
 
       ListScope Opcodes(SW, "Opcodes");
       decodeOpcodes(XData.UnwindByteCode(),
                     isAArch64 ? ES.EpilogueStartIndexAArch64()
                               : ES.EpilogueStartIndexARM(),
                     /*Prologue=*/false);
     }
   }
 
   if (XData.X()) {
     const uint32_t Address = XData.ExceptionHandlerRVA();
     const uint32_t Parameter = XData.ExceptionHandlerParameter();
     const size_t HandlerOffset = HeaderWords(XData)
                                + (XData.E() ? 0 : XData.EpilogueCount())
                                + XData.CodeWords();
 
-    ErrorOr<SymbolRef> Symbol =
-      getRelocatedSymbol(COFF, Section, HandlerOffset * sizeof(uint32_t));
+    ErrorOr<SymbolRef> Symbol = getRelocatedSymbol(
+        COFF, Section, Offset + HandlerOffset * sizeof(uint32_t));
     if (!Symbol)
       Symbol = getSymbol(COFF, Address, /*FunctionOnly=*/true);
+    if (!Symbol) {
+      ListScope EHS(SW, "ExceptionHandler");
+      SW.printString("Routine", "(null)");
+      return true;
+    }
 
     Expected<StringRef> Name = Symbol->getName();
     if (!Name) {
       std::string Buf;
       llvm::raw_string_ostream OS(Buf);
       logAllUnhandledErrors(Name.takeError(), OS, "");
       OS.flush();
       report_fatal_error(Buf);
if (!FunctionAddressOrErr) {
       std::string Buf;
       llvm::raw_string_ostream OS(Buf);
       logAllUnhandledErrors(FunctionAddressOrErr.takeError(), OS, "");
       OS.flush();
       report_fatal_error(Buf);
     }
     FunctionAddress = *FunctionAddressOrErr;
   } else {
-    const pe32_header *PEHeader;
-    if (COFF.getPE32Header(PEHeader))
-      return false;
-    FunctionAddress = PEHeader->ImageBase + RF.BeginAddress;
+    FunctionAddress = COFF.getImageBase() + RF.BeginAddress;
   }
 
   SW.printString("Function", formatSymbol(FunctionName, FunctionAddress));
 
   if (XDataRecord) {
     Expected<StringRef> Name = XDataRecord->getName();
     if (!Name) {
       std::string Buf;
if (XDataRecord) {
     Expected<section_iterator> SIOrErr = XDataRecord->getSection();
     if (!SIOrErr) {
       // TODO: Actually report errors helpfully.
       consumeError(SIOrErr.takeError());
       return false;
     }
     section_iterator SI = *SIOrErr;
 
-    return dumpXDataRecord(COFF, *SI, FunctionAddress, Address);
+    // FIXME: Do we need to add an offset from the relocation?
+    return dumpXDataRecord(COFF, *SI, FunctionAddress,
+                           RF.ExceptionInformationRVA());
   } else {
-    const pe32_header *PEHeader;
-    if (COFF.getPE32Header(PEHeader))
-      return false;
-
-    uint64_t Address = PEHeader->ImageBase + RF.ExceptionInformationRVA();
+    uint64_t Address = COFF.getImageBase() + RF.ExceptionInformationRVA();
     SW.printString("ExceptionRecord", formatSymbol("", Address));
 
-    ErrorOr<SectionRef> Section =
-      getSectionContaining(COFF, RF.ExceptionInformationRVA());
+    ErrorOr<SectionRef> Section = getSectionContaining(COFF, Address);
     if (!Section)
       return false;
 
-    return dumpXDataRecord(COFF, *Section, FunctionAddress,
-                           RF.ExceptionInformationRVA());
+    return dumpXDataRecord(COFF, *Section, FunctionAddress, Address);
   }
 }
 
 bool Decoder::dumpPackedEntry(const object::COFFObjectFile &COFF,
                               const SectionRef Section, uint64_t Offset,
                               unsigned Index, const RuntimeFunction &RF) {
   assert((RF.Flag() == RuntimeFunctionFlag::RFF_Packed ||
           RF.Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
bool Decoder::dumpProcedureDataEntry(const COFFObjectFile &COFF,
   const ulittle32_t *Data =
     reinterpret_cast<const ulittle32_t *>(Contents.data() + Offset);
 
   const RuntimeFunction Entry(Data);
   DictScope RFS(SW, "RuntimeFunction");
   if (Entry.Flag() == RuntimeFunctionFlag::RFF_Unpacked)
     return dumpUnpackedEntry(COFF, Section, Offset, Index, Entry);
   if (isAArch64) {
-    llvm::errs() << "Packed unwind data not yet supported for ARM64\n";
+    SW.startLine() << "Packed unwind data not yet supported for ARM64\n";
     return false;
   }
   return dumpPackedEntry(COFF, Section, Offset, Index, Entry);
 }
 
 void Decoder::dumpProcedureData(const COFFObjectFile &COFF,
                                 const SectionRef Section) {
   ArrayRef<uint8_t> Contents;