Support: Delete {aligned_,}{u,}{little,big}8_t

[ruiu]

Summary

A byte has no endianness, so these types don't make sense.
uint8_t should be used instead.

[• rafael]

LGTM

[Eugene.Zelenko]

Committed in r217631.

include/llvm/Object/COFF.h

union {
     StringTableOffset Offset;
   } Name;
 
   support::ulittle32_t Value;
   SectionNumberType SectionNumber;
 
   support::ulittle16_t Type;
 
-  support::ulittle8_t StorageClass;
-  support::ulittle8_t NumberOfAuxSymbols;
+  uint8_t StorageClass;
+  uint8_t NumberOfAuxSymbols;
 };
 
 typedef coff_symbol<support::ulittle16_t> coff_symbol16;
 typedef coff_symbol<support::ulittle32_t> coff_symbol32;
 
 class COFFSymbolRef {
 public:
   COFFSymbolRef(const coff_symbol16 *CS) : CS16(CS), CS32(nullptr) {}

 };
 
 struct coff_aux_section_definition {
   support::ulittle32_t Length;
   support::ulittle16_t NumberOfRelocations;
   support::ulittle16_t NumberOfLinenumbers;
   support::ulittle32_t CheckSum;
   support::ulittle16_t Number;
-  support::ulittle8_t Selection;
+  uint8_t              Selection;
 };
 
 struct coff_aux_clr_token {
-  support::ulittle8_t AuxType;
-  support::ulittle8_t Reserved;
+  uint8_t              AuxType;
+  uint8_t              Reserved;
   support::ulittle32_t SymbolTableIndex;
 };
 
 struct coff_load_configuration32 {
   support::ulittle32_t Characteristics;
   support::ulittle32_t TimeDateStamp;
   support::ulittle16_t MajorVersion;
   support::ulittle16_t MinorVersion;

include/llvm/Support/ARMWinEH.h

struct ExceptionDataRecord {
   }
 
   ArrayRef<support::ulittle32_t> EpilogueScopes() const {
     assert(E() == 0 && "epilogue scopes are only present when the E bit is 0");
     size_t Offset = HeaderWords(*this);
     return makeArrayRef(&Data[Offset], EpilogueCount());
   }
 
-  ArrayRef<support::ulittle8_t> UnwindByteCode() const {
+  ArrayRef<uint8_t> UnwindByteCode() const {
     const size_t Offset = HeaderWords(*this)
                         + (E() ? 0 :  EpilogueCount());
-    const support::ulittle8_t *ByteCode =
-      reinterpret_cast<const support::ulittle8_t *>(&Data[Offset]);
+    const uint8_t *ByteCode =
+      reinterpret_cast<const uint8_t *>(&Data[Offset]);
     return makeArrayRef(ByteCode, CodeWords() * sizeof(uint32_t));
   }
 
   uint32_t ExceptionHandlerRVA() const {
     assert(X() && "Exception Handler RVA is only valid if the X bit is set");
     return Data[HeaderWords(*this) + EpilogueCount() + CodeWords()];
   }
 
   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) {
   return (XR.Data[0] & 0xff800000) ? 1 : 2;
 }
 }
 }
 }
 
 #endif
-

include/llvm/Support/Endian.h

public:
   private:
     void *Ptr;
   };
 };
 
 } // end namespace detail
 
 typedef detail::packed_endian_specific_integral
-                  <uint8_t, little, unaligned>  ulittle8_t;
-typedef detail::packed_endian_specific_integral
                   <uint16_t, little, unaligned> ulittle16_t;
 typedef detail::packed_endian_specific_integral
                   <uint32_t, little, unaligned> ulittle32_t;
 typedef detail::packed_endian_specific_integral
                   <uint64_t, little, unaligned> ulittle64_t;
 
 typedef detail::packed_endian_specific_integral
-                   <int8_t, little, unaligned>  little8_t;
-typedef detail::packed_endian_specific_integral
                    <int16_t, little, unaligned> little16_t;
 typedef detail::packed_endian_specific_integral
                    <int32_t, little, unaligned> little32_t;
 typedef detail::packed_endian_specific_integral
                    <int64_t, little, unaligned> little64_t;
 
 typedef detail::packed_endian_specific_integral
-                    <uint8_t, little, aligned>  aligned_ulittle8_t;
-typedef detail::packed_endian_specific_integral
                     <uint16_t, little, aligned> aligned_ulittle16_t;
 typedef detail::packed_endian_specific_integral
                     <uint32_t, little, aligned> aligned_ulittle32_t;
 typedef detail::packed_endian_specific_integral
                     <uint64_t, little, aligned> aligned_ulittle64_t;
 
 typedef detail::packed_endian_specific_integral
-                     <int8_t, little, aligned>  aligned_little8_t;
-typedef detail::packed_endian_specific_integral
                      <int16_t, little, aligned> aligned_little16_t;
 typedef detail::packed_endian_specific_integral
                      <int32_t, little, aligned> aligned_little32_t;
 typedef detail::packed_endian_specific_integral
                      <int64_t, little, aligned> aligned_little64_t;
 
 typedef detail::packed_endian_specific_integral
-                  <uint8_t, big, unaligned>     ubig8_t;
-typedef detail::packed_endian_specific_integral
                   <uint16_t, big, unaligned>    ubig16_t;
 typedef detail::packed_endian_specific_integral
                   <uint32_t, big, unaligned>    ubig32_t;
 typedef detail::packed_endian_specific_integral
                   <uint64_t, big, unaligned>    ubig64_t;
 
 typedef detail::packed_endian_specific_integral
-                   <int8_t, big, unaligned>     big8_t;
-typedef detail::packed_endian_specific_integral
                    <int16_t, big, unaligned>    big16_t;
 typedef detail::packed_endian_specific_integral
                    <int32_t, big, unaligned>    big32_t;
 typedef detail::packed_endian_specific_integral
                    <int64_t, big, unaligned>    big64_t;
 
 typedef detail::packed_endian_specific_integral
-                    <uint8_t, big, aligned>     aligned_ubig8_t;
-typedef detail::packed_endian_specific_integral
                     <uint16_t, big, aligned>    aligned_ubig16_t;
 typedef detail::packed_endian_specific_integral
                     <uint32_t, big, aligned>    aligned_ubig32_t;
 typedef detail::packed_endian_specific_integral
                     <uint64_t, big, aligned>    aligned_ubig64_t;
 
 typedef detail::packed_endian_specific_integral
-                     <int8_t, big, aligned>     aligned_big8_t;
-typedef detail::packed_endian_specific_integral
                      <int16_t, big, aligned>    aligned_big16_t;
 typedef detail::packed_endian_specific_integral
                      <int32_t, big, aligned>    aligned_big32_t;
 typedef detail::packed_endian_specific_integral
                      <int64_t, big, aligned>    aligned_big64_t;
 
 typedef detail::packed_endian_specific_integral
                   <uint16_t, native, unaligned> unaligned_uint16_t;

include/llvm/Support/Win64EH.h

enum UnwindOpcodes {
   UOP_SaveXMM128Big,
   UOP_PushMachFrame
 };
 
 /// UnwindCode - This union describes a single operation in a function prolog,
 /// or part thereof.
 union UnwindCode {
   struct {
-    support::ulittle8_t CodeOffset;
-    support::ulittle8_t UnwindOpAndOpInfo;
+    uint8_t CodeOffset;
+    uint8_t UnwindOpAndOpInfo;
   } u;
   support::ulittle16_t FrameOffset;
 
   uint8_t getUnwindOp() const {
     return u.UnwindOpAndOpInfo & 0x0F;
   }
   uint8_t getOpInfo() const {
     return (u.UnwindOpAndOpInfo >> 4) & 0x0F;

 struct RuntimeFunction {
   support::ulittle32_t StartAddress;
   support::ulittle32_t EndAddress;
   support::ulittle32_t UnwindInfoOffset;
 };
 
 /// UnwindInfo - An entry in the exception table.
 struct UnwindInfo {
-  support::ulittle8_t VersionAndFlags;
-  support::ulittle8_t PrologSize;
-  support::ulittle8_t NumCodes;
-  support::ulittle8_t FrameRegisterAndOffset;
+  uint8_t VersionAndFlags;
+  uint8_t PrologSize;
+  uint8_t NumCodes;
+  uint8_t FrameRegisterAndOffset;
   UnwindCode UnwindCodes[1];
 
   uint8_t getVersion() const {
     return VersionAndFlags & 0x07;
   }
   uint8_t getFlags() const {
     return (VersionAndFlags >> 3) & 0x1f;
   }

lib/Object/COFFObjectFile.cpp

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cctype>
 #include <limits>
 
 using namespace llvm;
 using namespace object;
 
-using support::ulittle8_t;
 using support::ulittle16_t;
 using support::ulittle32_t;
 using support::little16_t;
 
 // Returns false if size is greater than the buffer size. And sets ec.
 static bool checkSize(MemoryBufferRef M, std::error_code &EC, uint64_t Size) {
   if (M.getBufferSize() < Size) {
     EC = object_error::unexpected_eof;

tools/llvm-readobj/ARMWinEHPrinter.h

class Decoder {
   static const size_t PDataEntrySize;
 
   StreamWriter &SW;
   raw_ostream &OS;
 
   struct RingEntry {
     uint8_t Mask;
     uint8_t Value;
-    bool (Decoder::*Routine)(const support::ulittle8_t *, unsigned &, unsigned,
-                             bool);
+    bool (Decoder::*Routine)(const uint8_t *, unsigned &, unsigned, bool);
   };
   static const RingEntry Ring[];
 
-  bool opcode_0xxxxxxx(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_0xxxxxxx(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_10Lxxxxx(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_10Lxxxxx(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_1100xxxx(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_1100xxxx(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_11010Lxx(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_11010Lxx(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_11011Lxx(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_11011Lxx(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_11100xxx(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_11100xxx(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_111010xx(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_111010xx(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_1110110L(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_1110110L(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_11101110(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_11101110(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_11101111(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_11101111(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_11110101(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_11110101(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_11110110(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_11110110(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_11110111(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_11110111(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_11111000(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_11111000(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_11111001(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_11111001(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_11111010(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_11111010(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_11111011(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_11111011(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_11111100(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_11111100(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_11111101(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_11111101(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_11111110(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_11111110(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
-  bool opcode_11111111(const support::ulittle8_t *Opcodes, unsigned &Offset,
+  bool opcode_11111111(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
 
-  void decodeOpcodes(ArrayRef<support::ulittle8_t> Opcodes, unsigned Offset,
+  void decodeOpcodes(ArrayRef<uint8_t> Opcodes, unsigned Offset,
                      bool Prologue);
 
   void printRegisters(const std::pair<uint16_t, uint32_t> &RegisterMask);
 
   ErrorOr<object::SectionRef>
   getSectionContaining(const object::COFFObjectFile &COFF, uint64_t Address);
 
   ErrorOr<object::SymbolRef>
public:
   Decoder(StreamWriter &SW) : SW(SW), OS(SW.getOStream()) {}
   std::error_code dumpProcedureData(const object::COFFObjectFile &COFF);
 };
 }
 }
 }
 
 #endif
-

tools/llvm-readobj/ARMWinEHPrinter.cpp

for (const auto &Relocation : Section.relocations()) {
     if (auto Error = Relocation.getOffset(RelocationOffset))
       return Error;
     if (RelocationOffset == Offset)
       return *Relocation.getSymbol();
   }
   return readobj_error::unknown_symbol;
 }
 
-bool Decoder::opcode_0xxxxxxx(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_0xxxxxxx(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   uint8_t Imm = OC[Offset] & 0x7f;
   SW.startLine() << format("0x%02x                ; %s sp, #(%u * 4)\n",
                            OC[Offset],
                            static_cast<const char *>(Prologue ? "sub" : "add"),
                            Imm);
   ++Offset;
   return false;
 }
 
-bool Decoder::opcode_10Lxxxxx(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_10Lxxxxx(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   unsigned Link = (OC[Offset] & 0x20) >> 5;
   uint16_t RegisterMask = (Link << (Prologue ? 14 : 15))
                         | ((OC[Offset + 0] & 0x1f) << 8)
                         | ((OC[Offset + 1] & 0xff) << 0);
   assert((~RegisterMask & (1 << 13)) && "sp must not be set");
   assert((~RegisterMask & (1 << (Prologue ? 15 : 14))) && "pc must not be set");
 
   SW.startLine() << format("0x%02x 0x%02x           ; %s.w ",
                            OC[Offset + 0], OC[Offset + 1],
                            Prologue ? "push" : "pop");
   printRegisters(std::make_pair(RegisterMask, 0));
   OS << '\n';
 
   ++Offset, ++Offset;
   return false;
 }
 
-bool Decoder::opcode_1100xxxx(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_1100xxxx(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   if (Prologue)
     SW.startLine() << format("0x%02x                ; mov r%u, sp\n",
                              OC[Offset], OC[Offset] & 0xf);
   else
     SW.startLine() << format("0x%02x                ; mov sp, r%u\n",
                              OC[Offset], OC[Offset] & 0xf);
   ++Offset;
   return false;
 }
 
-bool Decoder::opcode_11010Lxx(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_11010Lxx(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   unsigned Link = (OC[Offset] & 0x4) >> 3;
   unsigned Count = (OC[Offset] & 0x3);
 
   uint16_t GPRMask = (Link << (Prologue ? 14 : 15))
                    | (((1 << (Count + 1)) - 1) << 4);
 
   SW.startLine() << format("0x%02x                ; %s ", OC[Offset],
                            Prologue ? "push" : "pop");
   printRegisters(std::make_pair(GPRMask, 0));
   OS << '\n';
 
   ++Offset;
   return false;
 }
 
-bool Decoder::opcode_11011Lxx(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_11011Lxx(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   unsigned Link = (OC[Offset] & 0x4) >> 2;
   unsigned Count = (OC[Offset] & 0x3) + 4;
 
   uint16_t GPRMask = (Link << (Prologue ? 14 : 15))
                    | (((1 << (Count + 1)) - 1) << 4);
 
   SW.startLine() << format("0x%02x                ; %s.w ", OC[Offset],
                            Prologue ? "push" : "pop");
   printRegisters(std::make_pair(GPRMask, 0));
   OS << '\n';
 
   ++Offset;
   return false;
 }
 
-bool Decoder::opcode_11100xxx(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_11100xxx(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   unsigned High = (OC[Offset] & 0x7);
   uint32_t VFPMask = (((1 << (High + 1)) - 1) << 8);
 
   SW.startLine() << format("0x%02x                ; %s ", OC[Offset],
                            Prologue ? "vpush" : "vpop");
   printRegisters(std::make_pair(0, VFPMask));
   OS << '\n';
 
   ++Offset;
   return false;
 }
 
-bool Decoder::opcode_111010xx(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_111010xx(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   uint16_t Imm = ((OC[Offset + 0] & 0x03) << 8) | ((OC[Offset + 1] & 0xff) << 0);
 
   SW.startLine() << format("0x%02x 0x%02x           ; %s.w sp, #(%u * 4)\n",
                            OC[Offset + 0], OC[Offset + 1],
                            static_cast<const char *>(Prologue ? "sub" : "add"),
                            Imm);
 
   ++Offset, ++Offset;
   return false;
 }
 
-bool Decoder::opcode_1110110L(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_1110110L(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   uint8_t GPRMask = ((OC[Offset + 0] & 0x01) << (Prologue ? 14 : 15))
                   | ((OC[Offset + 1] & 0xff) << 0);
 
   SW.startLine() << format("0x%02x 0x%02x           ; %s ", OC[Offset + 0],
                            OC[Offset + 1], Prologue ? "push" : "pop");
   printRegisters(std::make_pair(GPRMask, 0));
   OS << '\n';
 
   ++Offset, ++Offset;
   return false;
 }
 
-bool Decoder::opcode_11101110(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_11101110(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   assert(!Prologue && "may not be used in prologue");
 
   if (OC[Offset + 1] & 0xf0)
     SW.startLine() << format("0x%02x 0x%02x           ; reserved\n",
                              OC[Offset + 0], OC[Offset +  1]);
   else
     SW.startLine()
       << format("0x%02x 0x%02x           ; microsoft-specific (type: %u)\n",
                 OC[Offset + 0], OC[Offset + 1], OC[Offset + 1] & 0x0f);
 
   ++Offset, ++Offset;
   return false;
 }
 
-bool Decoder::opcode_11101111(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_11101111(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   assert(!Prologue && "may not be used in prologue");
 
   if (OC[Offset + 1] & 0xf0)
     SW.startLine() << format("0x%02x 0x%02x           ; reserved\n",
                              OC[Offset + 0], OC[Offset +  1]);
   else
     SW.startLine()
       << format("0x%02x 0x%02x           ; ldr.w lr, [sp], #%u\n",
                 OC[Offset + 0], OC[Offset + 1], OC[Offset + 1] << 2);
 
   ++Offset, ++Offset;
   return false;
 }
 
-bool Decoder::opcode_11110101(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_11110101(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   unsigned Start = (OC[Offset + 1] & 0xf0) >> 4;
   unsigned End = (OC[Offset + 1] & 0x0f) >> 0;
   uint32_t VFPMask = ((1 << (End - Start)) - 1) << Start;
 
   SW.startLine() << format("0x%02x 0x%02x           ; %s ", OC[Offset + 0],
                            OC[Offset + 1], Prologue ? "vpush" : "vpop");
   printRegisters(std::make_pair(0, VFPMask));
   OS << '\n';
 
   ++Offset, ++Offset;
   return false;
 }
 
-bool Decoder::opcode_11110110(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_11110110(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   unsigned Start = (OC[Offset + 1] & 0xf0) >> 4;
   unsigned End = (OC[Offset + 1] & 0x0f) >> 0;
   uint32_t VFPMask = ((1 << (End - Start)) - 1) << 16;
 
   SW.startLine() << format("0x%02x 0x%02x           ; %s ", OC[Offset + 0],
                            OC[Offset + 1], Prologue ? "vpush" : "vpop");
   printRegisters(std::make_pair(0, VFPMask));
   OS << '\n';
 
   ++Offset, ++Offset;
   return false;
 }
 
-bool Decoder::opcode_11110111(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_11110111(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   uint32_t Imm = (OC[Offset + 1] << 8) | (OC[Offset + 2] << 0);
 
   SW.startLine() << format("0x%02x 0x%02x 0x%02x      ; %s sp, sp, #(%u * 4)\n",
                            OC[Offset + 0], OC[Offset + 1], OC[Offset + 2],
                            static_cast<const char *>(Prologue ? "sub" : "add"),
                            Imm);
 
   ++Offset, ++Offset, ++Offset;
   return false;
 }
 
-bool Decoder::opcode_11111000(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_11111000(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   uint32_t Imm = (OC[Offset + 1] << 16)
                | (OC[Offset + 2] << 8)
                | (OC[Offset + 3] << 0);
 
   SW.startLine()
     << format("0x%02x 0x%02x 0x%02x 0x%02x ; %s sp, sp, #(%u * 4)\n",
               OC[Offset + 0], OC[Offset + 1], OC[Offset + 2], OC[Offset + 3],
               static_cast<const char *>(Prologue ? "sub" : "add"), Imm);
 
   ++Offset, ++Offset, ++Offset, ++Offset;
   return false;
 }
 
-bool Decoder::opcode_11111001(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_11111001(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   uint32_t Imm = (OC[Offset + 1] << 8) | (OC[Offset + 2] << 0);
 
   SW.startLine()
     << format("0x%02x 0x%02x 0x%02x      ; %s.w sp, sp, #(%u * 4)\n",
               OC[Offset + 0], OC[Offset + 1], OC[Offset + 2],
               static_cast<const char *>(Prologue ? "sub" : "add"), Imm);
 
   ++Offset, ++Offset, ++Offset;
   return false;
 }
 
-bool Decoder::opcode_11111010(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_11111010(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   uint32_t Imm = (OC[Offset + 1] << 16)
                | (OC[Offset + 2] << 8)
                | (OC[Offset + 3] << 0);
 
   SW.startLine()
     << format("0x%02x 0x%02x 0x%02x 0x%02x ; %s.w sp, sp, #(%u * 4)\n",
               OC[Offset + 0], OC[Offset + 1], OC[Offset + 2], OC[Offset + 3],
               static_cast<const char *>(Prologue ? "sub" : "add"), Imm);
 
   ++Offset, ++Offset, ++Offset, ++Offset;
   return false;
 }
 
-bool Decoder::opcode_11111011(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_11111011(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   SW.startLine() << format("0x%02x                ; nop\n", OC[Offset]);
   ++Offset;
   return false;
 }
 
-bool Decoder::opcode_11111100(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_11111100(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   SW.startLine() << format("0x%02x                ; nop.w\n", OC[Offset]);
   ++Offset;
   return false;
 }
 
-bool Decoder::opcode_11111101(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_11111101(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   SW.startLine() << format("0x%02x                ; b\n", OC[Offset]);
   ++Offset;
   return true;
 }
 
-bool Decoder::opcode_11111110(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_11111110(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   SW.startLine() << format("0x%02x                ; b.w\n", OC[Offset]);
   ++Offset;
   return true;
 }
 
-bool Decoder::opcode_11111111(const ulittle8_t *OC, unsigned &Offset,
+bool Decoder::opcode_11111111(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   ++Offset;
   return true;
 }
 
-void Decoder::decodeOpcodes(ArrayRef<ulittle8_t> Opcodes, unsigned Offset,
+void Decoder::decodeOpcodes(ArrayRef<uint8_t> Opcodes, unsigned Offset,
                             bool Prologue) {
   assert((!Prologue || Offset == 0) && "prologue should always use offset 0");
 
   bool Terminated = false;
   for (unsigned OI = Offset, OE = Opcodes.size(); !Terminated && OI < OE; ) {
     for (unsigned DI = 0;; ++DI) {
       if ((Opcodes[OI] & Ring[DI].Mask) == Ring[DI].Value) {
         Terminated = (this->*Ring[DI].Routine)(Opcodes.data(), OI, 0, Prologue);
bool Decoder::dumpXDataRecord(const COFFObjectFile &COFF,
   SW.printBoolean("EpiloguePacked", XData.E());
   SW.printBoolean("Fragment", XData.F());
   SW.printNumber(XData.E() ? "EpilogueOffset" : "EpilogueScopes",
                  XData.EpilogueCount());
   SW.printNumber("ByteCodeLength",
                  static_cast<uint64_t>(XData.CodeWords() * sizeof(uint32_t)));
 
   if (XData.E()) {
-    ArrayRef<ulittle8_t> UC = XData.UnwindByteCode();
+    ArrayRef<uint8_t> UC = XData.UnwindByteCode();
     if (!XData.F()) {
       ListScope PS(SW, "Prologue");
       decodeOpcodes(UC, 0, /*Prologue=*/true);
     }
     if (XData.EpilogueCount()) {
       ListScope ES(SW, "Epilogue");
       decodeOpcodes(UC, XData.EpilogueCount(), /*Prologue=*/false);
     }
for (const auto &Section : COFF.sections()) {
     if (SectionName.startswith(".pdata"))
       dumpProcedureData(COFF, Section);
   }
   return std::error_code();
 }
 }
 }
 }
-