reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

 7178 static const uint8_t OTable[] = {
 9584   static const uint8_t IntrinsicsToAttributesMap[] = {

  198 enum SubtargetFeatureBits : uint8_t {
 1298 static const uint8_t TiedAsmOperandTable[][3] = {
 3105 static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][13] = {
 6464   const uint8_t *Converter = ConversionTable[Kind];
 6467   for (const uint8_t *p = Converter; *p; p+= 2) {
 6798   const uint8_t *Converter = ConversionTable[Kind];
 6799   for (const uint8_t *p = Converter; *p; p+= 2) {
12395   const uint8_t *Converter = ConversionTable[Kind];
12396   for (const uint8_t *p = Converter; *p; p+= 2) {
12572 enum : uint8_t {
12661     uint8_t RequiredFeaturesIdx;
27602     uint8_t OperandMask;
27604     uint8_t RequiredFeaturesIdx;

13297     printImm8OptLsl<uint8_t>(MI, 2, STI, O);
14647   static const uint8_t RegAsmOffsetvlist1[] = {
14730   static const uint8_t RegAsmOffsetvreg[] = {

14135     printImm8OptLsl<uint8_t>(MI, 2, STI, O);
15363   static const uint8_t RegAsmOffsetvlist1[] = {
15446   static const uint8_t RegAsmOffsetvreg[] = {

   61 static const uint8_t DecoderTable32[] = {
25718 static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
25724   const uint8_t *Ptr = DecodeTable;

   35 enum SubtargetFeatureBits : uint8_t {

15601 enum SubtargetFeatureBits : uint8_t {
15858 enum : uint8_t {
15938   static uint8_t RequiredFeaturesRefs[] = {

 2284   const uint8_t FPR8Bits[] = {
 2294   const uint8_t FPR16Bits[] = {
 2304   const uint8_t PPRBits[] = {
 2314   const uint8_t PPR_3bBits[] = {
 2324   const uint8_t GPR32allBits[] = {
 2334   const uint8_t FPR32Bits[] = {
 2344   const uint8_t GPR32Bits[] = {
 2354   const uint8_t GPR32spBits[] = {
 2364   const uint8_t GPR32commonBits[] = {
 2374   const uint8_t GPR32argBits[] = {
 2384   const uint8_t CCRBits[] = {
 2394   const uint8_t GPR32sponlyBits[] = {
 2404   const uint8_t WSeqPairsClassBits[] = {
 2414   const uint8_t WSeqPairsClass_with_subo32_in_GPR32commonBits[] = {
 2424   const uint8_t WSeqPairsClass_with_sube32_in_GPR32argBits[] = {
 2434   const uint8_t GPR64allBits[] = {
 2444   const uint8_t FPR64Bits[] = {
 2454   const uint8_t GPR64Bits[] = {
 2464   const uint8_t GPR64spBits[] = {
 2474   const uint8_t GPR64commonBits[] = {
 2484   const uint8_t GPR64noipBits[] = {
 2494   const uint8_t GPR64common_and_GPR64noipBits[] = {
 2504   const uint8_t tcGPR64Bits[] = {
 2514   const uint8_t GPR64noip_and_tcGPR64Bits[] = {
 2524   const uint8_t GPR64argBits[] = {
 2534   const uint8_t rtcGPR64Bits[] = {
 2544   const uint8_t GPR64sponlyBits[] = {
 2554   const uint8_t DDBits[] = {
 2564   const uint8_t XSeqPairsClassBits[] = {
 2574   const uint8_t XSeqPairsClass_with_subo64_in_GPR64commonBits[] = {
 2584   const uint8_t XSeqPairsClass_with_subo64_in_GPR64noipBits[] = {
 2594   const uint8_t XSeqPairsClass_with_sube64_in_GPR64noipBits[] = {
 2604   const uint8_t XSeqPairsClass_with_sube64_in_tcGPR64Bits[] = {
 2614   const uint8_t XSeqPairsClass_with_sube64_in_GPR64noip_and_tcGPR64Bits[] = {
 2624   const uint8_t XSeqPairsClass_with_subo64_in_tcGPR64Bits[] = {
 2634   const uint8_t XSeqPairsClass_with_subo64_in_GPR64noip_and_tcGPR64Bits[] = {
 2644   const uint8_t XSeqPairsClass_with_sub_32_in_GPR32argBits[] = {
 2654   const uint8_t XSeqPairsClass_with_sube64_in_rtcGPR64Bits[] = {
 2664   const uint8_t FPR128Bits[] = {
 2674   const uint8_t ZPRBits[] = {
 2684   const uint8_t FPR128_loBits[] = {
 2694   const uint8_t ZPR_4bBits[] = {
 2704   const uint8_t ZPR_3bBits[] = {
 2714   const uint8_t DDDBits[] = {
 2724   const uint8_t DDDDBits[] = {
 2734   const uint8_t QQBits[] = {
 2744   const uint8_t ZPR2Bits[] = {
 2754   const uint8_t QQ_with_qsub0_in_FPR128_loBits[] = {
 2764   const uint8_t QQ_with_qsub1_in_FPR128_loBits[] = {
 2774   const uint8_t ZPR2_with_zsub1_in_ZPR_4bBits[] = {
 2784   const uint8_t ZPR2_with_zsub_in_FPR128_loBits[] = {
 2794   const uint8_t QQ_with_qsub0_in_FPR128_lo_and_QQ_with_qsub1_in_FPR128_loBits[] = {
 2804   const uint8_t ZPR2_with_zsub_in_FPR128_lo_and_ZPR2_with_zsub1_in_ZPR_4bBits[] = {
 2814   const uint8_t ZPR2_with_zsub0_in_ZPR_3bBits[] = {
 2824   const uint8_t ZPR2_with_zsub1_in_ZPR_3bBits[] = {
 2834   const uint8_t ZPR2_with_zsub_in_FPR128_lo_and_ZPR2_with_zsub1_in_ZPR_3bBits[] = {
 2844   const uint8_t QQQBits[] = {
 2854   const uint8_t ZPR3Bits[] = {
 2864   const uint8_t QQQ_with_qsub0_in_FPR128_loBits[] = {
 2874   const uint8_t QQQ_with_qsub1_in_FPR128_loBits[] = {
 2884   const uint8_t QQQ_with_qsub2_in_FPR128_loBits[] = {
 2894   const uint8_t ZPR3_with_zsub1_in_ZPR_4bBits[] = {
 2904   const uint8_t ZPR3_with_zsub2_in_ZPR_4bBits[] = {
 2914   const uint8_t ZPR3_with_zsub_in_FPR128_loBits[] = {
 2924   const uint8_t QQQ_with_qsub0_in_FPR128_lo_and_QQQ_with_qsub1_in_FPR128_loBits[] = {
 2934   const uint8_t QQQ_with_qsub1_in_FPR128_lo_and_QQQ_with_qsub2_in_FPR128_loBits[] = {
 2944   const uint8_t ZPR3_with_zsub1_in_ZPR_4b_and_ZPR3_with_zsub2_in_ZPR_4bBits[] = {
 2954   const uint8_t ZPR3_with_zsub_in_FPR128_lo_and_ZPR3_with_zsub1_in_ZPR_4bBits[] = {
 2964   const uint8_t QQQ_with_qsub0_in_FPR128_lo_and_QQQ_with_qsub2_in_FPR128_loBits[] = {
 2974   const uint8_t ZPR3_with_zsub_in_FPR128_lo_and_ZPR3_with_zsub2_in_ZPR_4bBits[] = {
 2984   const uint8_t ZPR3_with_zsub0_in_ZPR_3bBits[] = {
 2994   const uint8_t ZPR3_with_zsub1_in_ZPR_3bBits[] = {
 3004   const uint8_t ZPR3_with_zsub2_in_ZPR_3bBits[] = {
 3014   const uint8_t ZPR3_with_zsub1_in_ZPR_3b_and_ZPR3_with_zsub2_in_ZPR_3bBits[] = {
 3024   const uint8_t ZPR3_with_zsub_in_FPR128_lo_and_ZPR3_with_zsub1_in_ZPR_3bBits[] = {
 3034   const uint8_t ZPR3_with_zsub_in_FPR128_lo_and_ZPR3_with_zsub2_in_ZPR_3bBits[] = {
 3044   const uint8_t QQQQBits[] = {
 3054   const uint8_t ZPR4Bits[] = {
 3064   const uint8_t QQQQ_with_qsub0_in_FPR128_loBits[] = {
 3074   const uint8_t QQQQ_with_qsub1_in_FPR128_loBits[] = {
 3084   const uint8_t QQQQ_with_qsub2_in_FPR128_loBits[] = {
 3094   const uint8_t QQQQ_with_qsub3_in_FPR128_loBits[] = {
 3104   const uint8_t ZPR4_with_zsub1_in_ZPR_4bBits[] = {
 3114   const uint8_t ZPR4_with_zsub2_in_ZPR_4bBits[] = {
 3124   const uint8_t ZPR4_with_zsub3_in_ZPR_4bBits[] = {
 3134   const uint8_t ZPR4_with_zsub_in_FPR128_loBits[] = {
 3144   const uint8_t QQQQ_with_qsub0_in_FPR128_lo_and_QQQQ_with_qsub1_in_FPR128_loBits[] = {
 3154   const uint8_t QQQQ_with_qsub1_in_FPR128_lo_and_QQQQ_with_qsub2_in_FPR128_loBits[] = {
 3164   const uint8_t QQQQ_with_qsub2_in_FPR128_lo_and_QQQQ_with_qsub3_in_FPR128_loBits[] = {
 3174   const uint8_t ZPR4_with_zsub1_in_ZPR_4b_and_ZPR4_with_zsub2_in_ZPR_4bBits[] = {
 3184   const uint8_t ZPR4_with_zsub2_in_ZPR_4b_and_ZPR4_with_zsub3_in_ZPR_4bBits[] = {
 3194   const uint8_t ZPR4_with_zsub_in_FPR128_lo_and_ZPR4_with_zsub1_in_ZPR_4bBits[] = {
 3204   const uint8_t QQQQ_with_qsub0_in_FPR128_lo_and_QQQQ_with_qsub2_in_FPR128_loBits[] = {
 3214   const uint8_t QQQQ_with_qsub1_in_FPR128_lo_and_QQQQ_with_qsub3_in_FPR128_loBits[] = {
 3224   const uint8_t ZPR4_with_zsub1_in_ZPR_4b_and_ZPR4_with_zsub3_in_ZPR_4bBits[] = {
 3234   const uint8_t ZPR4_with_zsub_in_FPR128_lo_and_ZPR4_with_zsub2_in_ZPR_4bBits[] = {
 3244   const uint8_t QQQQ_with_qsub0_in_FPR128_lo_and_QQQQ_with_qsub3_in_FPR128_loBits[] = {
 3254   const uint8_t ZPR4_with_zsub_in_FPR128_lo_and_ZPR4_with_zsub3_in_ZPR_4bBits[] = {
 3264   const uint8_t ZPR4_with_zsub0_in_ZPR_3bBits[] = {
 3274   const uint8_t ZPR4_with_zsub1_in_ZPR_3bBits[] = {
 3284   const uint8_t ZPR4_with_zsub2_in_ZPR_3bBits[] = {
 3294   const uint8_t ZPR4_with_zsub3_in_ZPR_3bBits[] = {
 3304   const uint8_t ZPR4_with_zsub1_in_ZPR_3b_and_ZPR4_with_zsub2_in_ZPR_3bBits[] = {
 3314   const uint8_t ZPR4_with_zsub2_in_ZPR_3b_and_ZPR4_with_zsub3_in_ZPR_3bBits[] = {
 3324   const uint8_t ZPR4_with_zsub_in_FPR128_lo_and_ZPR4_with_zsub1_in_ZPR_3bBits[] = {
 3334   const uint8_t ZPR4_with_zsub1_in_ZPR_3b_and_ZPR4_with_zsub3_in_ZPR_3bBits[] = {
 3344   const uint8_t ZPR4_with_zsub_in_FPR128_lo_and_ZPR4_with_zsub2_in_ZPR_3bBits[] = {
 3354   const uint8_t ZPR4_with_zsub_in_FPR128_lo_and_ZPR4_with_zsub3_in_ZPR_3bBits[] = {
 8936   static const uint8_t RowMap[99] = {
 8939   static const uint8_t Rows[12][99] = {
 8961     uint8_t  RotateLeft;
 9146   static const uint8_t Table[108][99] = {
20238   static const uint8_t PressureLimitTable[] = {

 1160 const BTI *lookupBTIByEncoding(uint8_t Encoding);
 1200 const BTI *lookupBTIByEncoding(uint8_t Encoding) {
 1202     uint8_t Encoding;
 1212     uint8_t Encoding;
 1234 const DB *lookupDBByEncoding(uint8_t Encoding);
 1292 const DB *lookupDBByEncoding(uint8_t Encoding) {
 1294     uint8_t Encoding;
 1313     uint8_t Encoding;
 1483 const ExactFPImm *lookupExactFPImmByEnum(uint8_t Enum);
 1495 const ExactFPImm *lookupExactFPImmByEnum(uint8_t Enum) {
 1497     uint8_t Enum;
 1620 const ISB *lookupISBByEncoding(uint8_t Encoding);
 1656 const ISB *lookupISBByEncoding(uint8_t Encoding) {
 1658     uint8_t Encoding;
 1666     uint8_t Encoding;
 1756 const PRFM *lookupPRFMByEncoding(uint8_t Encoding);
 1826 const PRFM *lookupPRFMByEncoding(uint8_t Encoding) {
 1828     uint8_t Encoding;
 1853     uint8_t Encoding;
 1875 const PSB *lookupPSBByEncoding(uint8_t Encoding);
 1911 const PSB *lookupPSBByEncoding(uint8_t Encoding) {
 1913     uint8_t Encoding;
 1921     uint8_t Encoding;
 1943 const PState *lookupPStateByEncoding(uint8_t Encoding);
 1993 const PState *lookupPStateByEncoding(uint8_t Encoding) {
 1995     uint8_t Encoding;
 2010     uint8_t Encoding;
 2032 const SVEPREDPAT *lookupSVEPREDPATByEncoding(uint8_t Encoding);
 2100 const SVEPREDPAT *lookupSVEPREDPATByEncoding(uint8_t Encoding) {
 2102     uint8_t Encoding;
 2126     uint8_t Encoding;
 2148 const SVEPRFM *lookupSVEPRFMByEncoding(uint8_t Encoding);
 2206 const SVEPRFM *lookupSVEPRFMByEncoding(uint8_t Encoding) {
 2208     uint8_t Encoding;
 2227     uint8_t Encoding;
 4920 const TSB *lookupTSBByEncoding(uint8_t Encoding);
 4956 const TSB *lookupTSBByEncoding(uint8_t Encoding) {
 4958     uint8_t Encoding;

   57 enum SubtargetFeatureBits : uint8_t {
 3274 static const uint8_t TiedAsmOperandTable[][3] = {
 3483 static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][19] = {
 3781   const uint8_t *Converter = ConversionTable[Kind];
 3790   for (const uint8_t *p = Converter; *p; p+= 2) {
 4010   const uint8_t *Converter = ConversionTable[Kind];
 4011   for (const uint8_t *p = Converter; *p; p+= 2) {
10315   const uint8_t *Converter = ConversionTable[Kind];
10316   for (const uint8_t *p = Converter; *p; p+= 2) {
10781 enum : uint8_t {
11053     uint8_t ConvertFn;
11054     uint8_t RequiredFeaturesIdx;
24133     uint8_t RequiredFeaturesIdx;

   61 static const uint8_t DecoderTableAMDGPU32[] = {
  220 static const uint8_t DecoderTableAMDGPU64[] = {
 1886 static const uint8_t DecoderTableDPP64[] = {
 2378 static const uint8_t DecoderTableDPP864[] = {
 2680 static const uint8_t DecoderTableGFX1032[] = {
 4148 static const uint8_t DecoderTableGFX1064[] = {
11572 static const uint8_t DecoderTableGFX664[] = {
11582 static const uint8_t DecoderTableGFX6GFX732[] = {
13062 static const uint8_t DecoderTableGFX6GFX764[] = {
17388 static const uint8_t DecoderTableGFX732[] = {
17419 static const uint8_t DecoderTableGFX764[] = {
18030 static const uint8_t DecoderTableGFX832[] = {
19574 static const uint8_t DecoderTableGFX864[] = {
27267 static const uint8_t DecoderTableGFX80_UNPACKED64[] = {
27585 static const uint8_t DecoderTableGFX932[] = {
27622 static const uint8_t DecoderTableGFX964[] = {
27736 static const uint8_t DecoderTableGFX9_DL64[] = {
27751 static const uint8_t DecoderTableSDWA64[] = {
29282 static const uint8_t DecoderTableSDWA1064[] = {
31123 static const uint8_t DecoderTableSDWA964[] = {
41982 static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
41988   const uint8_t *Ptr = DecodeTable;

   35 enum SubtargetFeatureBits : uint8_t {

34512 enum SubtargetFeatureBits : uint8_t {
34753 enum : uint8_t {
35091   static uint8_t RequiredFeaturesRefs[] = {

10009   const uint8_t SCC_CLASSBits[] = {
10019   const uint8_t SReg_1Bits[] = {
10029   const uint8_t SReg_1_XEXECBits[] = {
10039   const uint8_t SReg_1_with_sub0Bits[] = {
10049   const uint8_t SReg_1_XEXEC_with_sub0Bits[] = {
10059   const uint8_t SReg_1_with_sub0_with_sub0_in_SGPR_32Bits[] = {
10069   const uint8_t SReg_1_with_sub0_with_sub0_in_TTMP_32Bits[] = {
10079   const uint8_t VReg_1Bits[] = {
10089   const uint8_t AV_32Bits[] = {
10099   const uint8_t VS_32Bits[] = {
10109   const uint8_t VRegOrLds_32Bits[] = {
10119   const uint8_t AGPR_32Bits[] = {
10129   const uint8_t VGPR_32Bits[] = {
10139   const uint8_t SRegOrLds_32Bits[] = {
10149   const uint8_t SReg_32Bits[] = {
10159   const uint8_t SReg_32_XEXEC_HIBits[] = {
10169   const uint8_t SReg_32_XM0Bits[] = {
10179   const uint8_t SRegOrLds_32_and_SReg_1Bits[] = {
10189   const uint8_t SReg_32_XM0_XEXECBits[] = {
10199   const uint8_t SGPR_32Bits[] = {
10209   const uint8_t TTMP_32Bits[] = {
10219   const uint8_t Pseudo_SReg_32Bits[] = {
10229   const uint8_t LDS_DIRECT_CLASSBits[] = {
10239   const uint8_t M0_CLASSBits[] = {
10249   const uint8_t AV_64Bits[] = {
10259   const uint8_t VS_64Bits[] = {
10269   const uint8_t AReg_64Bits[] = {
10279   const uint8_t VReg_64Bits[] = {
10289   const uint8_t SReg_64Bits[] = {
10299   const uint8_t SReg_64_XEXECBits[] = {
10309   const uint8_t SGPR_64Bits[] = {
10319   const uint8_t CCR_SGPR_64Bits[] = {
10329   const uint8_t TTMP_64Bits[] = {
10339   const uint8_t VReg_96Bits[] = {
10349   const uint8_t SGPR_96Bits[] = {
10359   const uint8_t SReg_96Bits[] = {
10369   const uint8_t SGPR_96_with_sub0_sub1Bits[] = {
10379   const uint8_t SGPR_96_with_sub1_sub2Bits[] = {
10389   const uint8_t SGPR_96_with_sub0_sub1_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10399   const uint8_t SGPR_96_with_sub1_sub2_with_sub1_sub2_in_CCR_SGPR_64Bits[] = {
10409   const uint8_t AReg_128Bits[] = {
10419   const uint8_t VReg_128Bits[] = {
10429   const uint8_t SReg_128Bits[] = {
10439   const uint8_t SGPR_128Bits[] = {
10449   const uint8_t SGPR_128_with_sub0_sub1_sub2Bits[] = {
10459   const uint8_t SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10469   const uint8_t SGPR_128_with_sub1_sub2_sub3Bits[] = {
10479   const uint8_t TTMP_128Bits[] = {
10489   const uint8_t SGPR_128_with_sub0_sub1_sub2_and_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10499   const uint8_t SGPR_128_with_sub1_sub2_sub3_and_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10509   const uint8_t Pseudo_SReg_128Bits[] = {
10519   const uint8_t VReg_160Bits[] = {
10529   const uint8_t SGPR_160Bits[] = {
10539   const uint8_t SReg_160Bits[] = {
10549   const uint8_t SGPR_160_with_sub0_sub1_sub2Bits[] = {
10559   const uint8_t SGPR_160_with_sub2_sub3_sub4Bits[] = {
10569   const uint8_t SGPR_160_with_sub0_sub1_sub2_sub3_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10579   const uint8_t SGPR_160_with_sub1_sub2_sub3Bits[] = {
10589   const uint8_t SGPR_160_with_sub0_sub1_sub2_and_SGPR_160_with_sub0_sub1_sub2_sub3_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10599   const uint8_t SGPR_160_with_sub2_sub3_sub4_and_SGPR_160_with_sub0_sub1_sub2_sub3_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10609   const uint8_t SGPR_160_with_sub1_sub2_sub3_and_SGPR_160_with_sub0_sub1_sub2_sub3_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10619   const uint8_t VReg_256Bits[] = {
10629   const uint8_t SReg_256Bits[] = {
10639   const uint8_t SGPR_256Bits[] = {
10649   const uint8_t SGPR_256_with_sub0_sub1_sub2Bits[] = {
10659   const uint8_t SGPR_256_with_sub0_sub1_sub2_sub3_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10669   const uint8_t SGPR_256_with_sub1_sub2_sub3Bits[] = {
10679   const uint8_t SGPR_256_with_sub2_sub3_sub4Bits[] = {
10689   const uint8_t SGPR_256_with_sub4_sub5_sub6_sub7_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10699   const uint8_t SGPR_256_with_sub0_sub1_sub2_and_SGPR_256_with_sub0_sub1_sub2_sub3_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10709   const uint8_t SGPR_256_with_sub2_sub3_sub4_and_SGPR_256_with_sub0_sub1_sub2_sub3_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10719   const uint8_t TTMP_256Bits[] = {
10729   const uint8_t SGPR_256_with_sub1_sub2_sub3_and_SGPR_256_with_sub0_sub1_sub2_sub3_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10739   const uint8_t SGPR_256_with_sub2_sub3_sub4_and_SGPR_256_with_sub4_sub5_sub6_sub7_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10749   const uint8_t AReg_512Bits[] = {
10759   const uint8_t VReg_512Bits[] = {
10769   const uint8_t SReg_512Bits[] = {
10779   const uint8_t SGPR_512Bits[] = {
10789   const uint8_t SGPR_512_with_sub0_sub1_sub2Bits[] = {
10799   const uint8_t SGPR_512_with_sub0_sub1_sub2_sub3_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10809   const uint8_t SGPR_512_with_sub2_sub3_sub4Bits[] = {
10819   const uint8_t SGPR_512_with_sub1_sub2_sub3Bits[] = {
10829   const uint8_t SGPR_512_with_sub4_sub5_sub6_sub7_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10839   const uint8_t SGPR_512_with_sub8_sub9_sub10_sub11_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10849   const uint8_t SGPR_512_with_sub12_sub13_sub14_sub15_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10859   const uint8_t SGPR_512_with_sub0_sub1_sub2_and_SGPR_512_with_sub0_sub1_sub2_sub3_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10869   const uint8_t SGPR_512_with_sub2_sub3_sub4_and_SGPR_512_with_sub0_sub1_sub2_sub3_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10879   const uint8_t SGPR_512_with_sub0_sub1_sub2_and_SGPR_512_with_sub8_sub9_sub10_sub11_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10889   const uint8_t SGPR_512_with_sub1_sub2_sub3_and_SGPR_512_with_sub0_sub1_sub2_sub3_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10899   const uint8_t SGPR_512_with_sub2_sub3_sub4_and_SGPR_512_with_sub4_sub5_sub6_sub7_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10909   const uint8_t SGPR_512_with_sub1_sub2_sub3_and_SGPR_512_with_sub12_sub13_sub14_sub15_in_SGPR_128_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10919   const uint8_t TTMP_512Bits[] = {
10929   const uint8_t AReg_1024Bits[] = {
10939   const uint8_t VReg_1024Bits[] = {
10949   const uint8_t SGPR_1024Bits[] = {
10959   const uint8_t SReg_1024Bits[] = {
10969   const uint8_t SGPR_1024_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
10979   const uint8_t SGPR_1024_with_sub0_sub1_sub2Bits[] = {
10989   const uint8_t SGPR_1024_with_sub4_sub5_in_CCR_SGPR_64Bits[] = {
10999   const uint8_t SGPR_1024_with_sub1_sub2_sub3Bits[] = {
11009   const uint8_t SGPR_1024_with_sub2_sub3_sub4Bits[] = {
11019   const uint8_t SGPR_1024_with_sub8_sub9_in_CCR_SGPR_64Bits[] = {
11029   const uint8_t SGPR_1024_with_sub12_sub13_in_CCR_SGPR_64Bits[] = {
11039   const uint8_t SGPR_1024_with_sub16_sub17_in_CCR_SGPR_64Bits[] = {
11049   const uint8_t SGPR_1024_with_sub0_sub1_sub2_and_SGPR_1024_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
11059   const uint8_t SGPR_1024_with_sub20_sub21_in_CCR_SGPR_64Bits[] = {
11069   const uint8_t SGPR_1024_with_sub2_sub3_sub4_and_SGPR_1024_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
11079   const uint8_t SGPR_1024_with_sub0_sub1_sub2_and_SGPR_1024_with_sub8_sub9_in_CCR_SGPR_64Bits[] = {
11089   const uint8_t SGPR_1024_with_sub1_sub2_sub3_and_SGPR_1024_with_sub0_sub1_in_CCR_SGPR_64Bits[] = {
11099   const uint8_t SGPR_1024_with_sub24_sub25_in_CCR_SGPR_64Bits[] = {
11109   const uint8_t SGPR_1024_with_sub2_sub3_sub4_and_SGPR_1024_with_sub4_sub5_in_CCR_SGPR_64Bits[] = {
11119   const uint8_t SGPR_1024_with_sub1_sub2_sub3_and_SGPR_1024_with_sub12_sub13_in_CCR_SGPR_64Bits[] = {
11129   const uint8_t SGPR_1024_with_sub28_sub29_in_CCR_SGPR_64Bits[] = {
11139   const uint8_t SGPR_1024_with_sub2_sub3_sub4_and_SGPR_1024_with_sub16_sub17_in_CCR_SGPR_64Bits[] = {
25493   static const uint8_t RowMap[192] = {
25496   static const uint8_t Rows[31][192] = {
25537     uint8_t  RotateLeft;
25796   static const uint8_t Table[114][192] = {

  772 const MIMGDimInfo *getMIMGDimInfoByEncoding(uint8_t Encoding) {
  774     uint8_t Encoding;
 4908 const MIMGInfo *getMIMGOpcodeHelper(unsigned BaseOpcode, unsigned MIMGEncoding, uint8_t VDataDwords, uint8_t VAddrDwords) {
 4908 const MIMGInfo *getMIMGOpcodeHelper(unsigned BaseOpcode, unsigned MIMGEncoding, uint8_t VDataDwords, uint8_t VAddrDwords) {
 4912     uint8_t VDataDwords;
 4913     uint8_t VAddrDwords;
 9153 const MTBUFInfo *getMTBUFInfoFromBaseOpcodeAndElements(unsigned BaseOpcode, uint8_t elements);
 9398 const MTBUFInfo *getMTBUFInfoFromBaseOpcodeAndElements(unsigned BaseOpcode, uint8_t elements) {
 9401     uint8_t elements;
 9625     uint8_t elements;
 9896 const MUBUFInfo *getMUBUFInfoFromBaseOpcodeAndElements(unsigned BaseOpcode, uint8_t elements);
10774 const MUBUFInfo *getMUBUFInfoFromBaseOpcodeAndElements(unsigned BaseOpcode, uint8_t elements) {
10777     uint8_t elements;
11634     uint8_t elements;

 1768 enum SubtargetFeatureBits : uint8_t {
 1785 enum : uint8_t {
 1797   static uint8_t RequiredFeaturesRefs[] = {

 6641   const uint8_t R600_Reg32Bits[] = {
 6651   const uint8_t R600_TReg32Bits[] = {
 6661   const uint8_t R600_TReg32_XBits[] = {
 6671   const uint8_t R600_AddrBits[] = {
 6681   const uint8_t R600_KC0Bits[] = {
 6691   const uint8_t R600_KC1Bits[] = {
 6701   const uint8_t R600_TReg32_WBits[] = {
 6711   const uint8_t R600_TReg32_YBits[] = {
 6721   const uint8_t R600_TReg32_ZBits[] = {
 6731   const uint8_t R600_ArrayBaseBits[] = {
 6741   const uint8_t R600_KC0_WBits[] = {
 6751   const uint8_t R600_KC0_XBits[] = {
 6761   const uint8_t R600_KC0_YBits[] = {
 6771   const uint8_t R600_KC0_ZBits[] = {
 6781   const uint8_t R600_KC1_WBits[] = {
 6791   const uint8_t R600_KC1_XBits[] = {
 6801   const uint8_t R600_KC1_YBits[] = {
 6811   const uint8_t R600_KC1_ZBits[] = {
 6821   const uint8_t R600_LDS_SRC_REGBits[] = {
 6831   const uint8_t R600_PredicateBits[] = {
 6841   const uint8_t R600_Addr_WBits[] = {
 6851   const uint8_t R600_Addr_YBits[] = {
 6861   const uint8_t R600_Addr_ZBits[] = {
 6871   const uint8_t R600_LDS_SRC_REG_and_R600_Reg32Bits[] = {
 6881   const uint8_t R600_Predicate_BitBits[] = {
 6891   const uint8_t R600_Reg64Bits[] = {
 6901   const uint8_t R600_Reg64VerticalBits[] = {
 6911   const uint8_t R600_Reg64Vertical_with_sub0_in_R600_TReg32_WBits[] = {
 6921   const uint8_t R600_Reg64Vertical_with_sub0_in_R600_TReg32_XBits[] = {
 6931   const uint8_t R600_Reg64Vertical_with_sub0_in_R600_TReg32_YBits[] = {
 6941   const uint8_t R600_Reg64Vertical_with_sub0_in_R600_TReg32_ZBits[] = {
 6951   const uint8_t R600_Reg128Bits[] = {
 6961   const uint8_t R600_Reg128VerticalBits[] = {
 6971   const uint8_t R600_Reg128Vertical_with_sub0_in_R600_TReg32_WBits[] = {
 6981   const uint8_t R600_Reg128Vertical_with_sub0_in_R600_TReg32_XBits[] = {
 6991   const uint8_t R600_Reg128Vertical_with_sub0_in_R600_TReg32_YBits[] = {
 7001   const uint8_t R600_Reg128Vertical_with_sub0_in_R600_TReg32_ZBits[] = {
11430   static const uint8_t Rows[1][16] = {
11441     uint8_t  RotateLeft;
11508   static const uint8_t Table[37][16] = {
12327   static const uint8_t RCSetStartTable[] = {
12337   static const uint8_t RUSetStartTable[] = {

  989   static const uint8_t RegAsmOffset[] = {

   61 static const uint8_t DecoderTable16[] = {
  348 static const uint8_t DecoderTable32[] = {
  724 static const uint8_t DecoderTable48[] = {
  752 static const uint8_t DecoderTable64[] = {
 1453 static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
 1459   const uint8_t *Ptr = DecodeTable;

  220   const uint8_t SREGBits[] = {
  230   const uint8_t GPR_SBits[] = {
  240   const uint8_t GPR32Bits[] = {
  250   const uint8_t GPR32_and_GPR_SBits[] = {
  741   static const uint8_t PressureLimitTable[] = {
  759   static const uint8_t RCSetStartTable[] = {
  769   static const uint8_t RUSetStartTable[] = {

  125 enum SubtargetFeatureBits : uint8_t {
 2118 static const uint8_t TiedAsmOperandTable[][3] = {
 2973 static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][17] = {
 4348   const uint8_t *Converter = ConversionTable[Kind];
 4351   for (const uint8_t *p = Converter; *p; p+= 2) {
 4805   const uint8_t *Converter = ConversionTable[Kind];
 4806   for (const uint8_t *p = Converter; *p; p+= 2) {
 9964 enum : uint8_t {
10179     uint8_t RequiredFeaturesIdx;
15320     uint8_t OperandMask;
15322     uint8_t RequiredFeaturesIdx;

12019   static const uint8_t RegAsmOffsetRegNamesRaw[] = {

   61 static const uint8_t DecoderTableARM32[] = {
 1804 static const uint8_t DecoderTableCoProc32[] = {
 1940 static const uint8_t DecoderTableMVE32[] = {
 6861 static const uint8_t DecoderTableNEONData32[] = {
10768 static const uint8_t DecoderTableNEONDup32[] = {
10861 static const uint8_t DecoderTableNEONLoadStore32[] = {
12248 static const uint8_t DecoderTableThumb16[] = {
12503 static const uint8_t DecoderTableThumb32[] = {
12520 static const uint8_t DecoderTableThumb216[] = {
12528 static const uint8_t DecoderTableThumb232[] = {
14233 static const uint8_t DecoderTableThumb2CoProc32[] = {
14393 static const uint8_t DecoderTableThumbSBit16[] = {
14472 static const uint8_t DecoderTableVFP32[] = {
15566 static const uint8_t DecoderTableVFPV832[] = {
16062 static const uint8_t DecoderTablev8Crypto32[] = {
16163 static const uint8_t DecoderTablev8NEON32[] = {
21760 static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
21766   const uint8_t *Ptr = DecodeTable;

   35 enum SubtargetFeatureBits : uint8_t {

 1571   const uint8_t HPRBits[] = {
 1581   const uint8_t FPWithVPRBits[] = {
 1591   const uint8_t SPRBits[] = {
 1601   const uint8_t FPWithVPR_with_ssub_0Bits[] = {
 1611   const uint8_t GPRBits[] = {
 1621   const uint8_t GPRwithAPSRBits[] = {
 1631   const uint8_t GPRwithZRBits[] = {
 1641   const uint8_t SPR_8Bits[] = {
 1651   const uint8_t GPRnopcBits[] = {
 1661   const uint8_t GPRwithAPSRnospBits[] = {
 1671   const uint8_t GPRwithZRnospBits[] = {
 1681   const uint8_t rGPRBits[] = {
 1691   const uint8_t tGPRwithpcBits[] = {
 1701   const uint8_t FPWithVPR_with_ssub_0_with_ssub_0_in_SPR_8Bits[] = {
 1711   const uint8_t hGPRBits[] = {
 1721   const uint8_t tGPRBits[] = {
 1731   const uint8_t tGPREvenBits[] = {
 1741   const uint8_t GPRnopc_and_hGPRBits[] = {
 1751   const uint8_t GPRwithAPSRnosp_and_hGPRBits[] = {
 1761   const uint8_t tGPROddBits[] = {
 1771   const uint8_t tcGPRBits[] = {
 1781   const uint8_t hGPR_and_tGPREvenBits[] = {
 1791   const uint8_t tGPR_and_tGPREvenBits[] = {
 1801   const uint8_t tGPR_and_tGPROddBits[] = {
 1811   const uint8_t tGPR_and_tcGPRBits[] = {
 1821   const uint8_t tGPREven_and_tcGPRBits[] = {
 1831   const uint8_t hGPR_and_tGPROddBits[] = {
 1841   const uint8_t tGPREven_and_tGPR_and_tcGPRBits[] = {
 1851   const uint8_t tGPROdd_and_tcGPRBits[] = {
 1861   const uint8_t CCRBits[] = {
 1871   const uint8_t GPRlrBits[] = {
 1881   const uint8_t GPRspBits[] = {
 1891   const uint8_t VCCRBits[] = {
 1901   const uint8_t cl_FPSCR_NZCVBits[] = {
 1911   const uint8_t hGPR_and_tGPRwithpcBits[] = {
 1921   const uint8_t hGPR_and_tcGPRBits[] = {
 1931   const uint8_t DPRBits[] = {
 1941   const uint8_t DPR_VFP2Bits[] = {
 1951   const uint8_t DPR_8Bits[] = {
 1961   const uint8_t GPRPairBits[] = {
 1971   const uint8_t GPRPairnospBits[] = {
 1981   const uint8_t GPRPair_with_gsub_0_in_tGPRBits[] = {
 1991   const uint8_t GPRPair_with_gsub_0_in_hGPRBits[] = {
 2001   const uint8_t GPRPair_with_gsub_0_in_tcGPRBits[] = {
 2011   const uint8_t GPRPair_with_gsub_1_in_tcGPRBits[] = {
 2021   const uint8_t GPRPairnosp_and_GPRPair_with_gsub_0_in_hGPRBits[] = {
 2031   const uint8_t GPRPair_with_gsub_1_in_GPRspBits[] = {
 2041   const uint8_t DPairSpcBits[] = {
 2051   const uint8_t DPairSpc_with_ssub_0Bits[] = {
 2061   const uint8_t DPairSpc_with_ssub_4Bits[] = {
 2071   const uint8_t DPairSpc_with_dsub_0_in_DPR_8Bits[] = {
 2081   const uint8_t DPairSpc_with_dsub_2_in_DPR_8Bits[] = {
 2091   const uint8_t DPairBits[] = {
 2101   const uint8_t DPair_with_ssub_0Bits[] = {
 2111   const uint8_t QPRBits[] = {
 2121   const uint8_t DPair_with_ssub_2Bits[] = {
 2131   const uint8_t DPair_with_dsub_0_in_DPR_8Bits[] = {
 2141   const uint8_t MQPRBits[] = {
 2151   const uint8_t QPR_VFP2Bits[] = {
 2161   const uint8_t DPair_with_dsub_1_in_DPR_8Bits[] = {
 2171   const uint8_t QPR_8Bits[] = {
 2181   const uint8_t DTripleBits[] = {
 2191   const uint8_t DTripleSpcBits[] = {
 2201   const uint8_t DTripleSpc_with_ssub_0Bits[] = {
 2211   const uint8_t DTriple_with_ssub_0Bits[] = {
 2221   const uint8_t DTriple_with_qsub_0_in_QPRBits[] = {
 2231   const uint8_t DTriple_with_ssub_2Bits[] = {
 2241   const uint8_t DTriple_with_ssub_2_ssub_3_ssub_4_ssub_5_in_QPRBits[] = {
 2251   const uint8_t DTripleSpc_with_ssub_4Bits[] = {
 2261   const uint8_t DTriple_with_ssub_4Bits[] = {
 2271   const uint8_t DTripleSpc_with_ssub_8Bits[] = {
 2281   const uint8_t DTripleSpc_with_dsub_0_in_DPR_8Bits[] = {
 2291   const uint8_t DTriple_with_dsub_0_in_DPR_8Bits[] = {
 2301   const uint8_t DTriple_with_qsub_0_in_MQPRBits[] = {
 2311   const uint8_t DTriple_with_ssub_0_and_DTriple_with_ssub_2_ssub_3_ssub_4_ssub_5_in_QPRBits[] = {
 2321   const uint8_t DTriple_with_dsub_1_in_DPR_8Bits[] = {
 2331   const uint8_t DTriple_with_ssub_2_ssub_3_ssub_4_ssub_5_in_MQPRBits[] = {
 2341   const uint8_t DTriple_with_ssub_4_and_DTriple_with_qsub_0_in_MQPRBits[] = {
 2351   const uint8_t DTripleSpc_with_dsub_2_in_DPR_8Bits[] = {
 2361   const uint8_t DTriple_with_dsub_2_in_DPR_8Bits[] = {
 2371   const uint8_t DTripleSpc_with_dsub_4_in_DPR_8Bits[] = {
 2381   const uint8_t DTriple_with_dsub_0_in_DPR_8_and_DTriple_with_ssub_2_ssub_3_ssub_4_ssub_5_in_MQPRBits[] = {
 2391   const uint8_t DTriple_with_qsub_0_in_QPR_8Bits[] = {
 2401   const uint8_t DTriple_with_dsub_2_in_DPR_8_and_DTriple_with_qsub_0_in_MQPRBits[] = {
 2411   const uint8_t DTriple_with_ssub_2_ssub_3_ssub_4_ssub_5_in_QPR_8Bits[] = {
 2421   const uint8_t DQuadSpcBits[] = {
 2431   const uint8_t DQuadSpc_with_ssub_0Bits[] = {
 2441   const uint8_t DQuadSpc_with_ssub_4Bits[] = {
 2451   const uint8_t DQuadSpc_with_ssub_8Bits[] = {
 2461   const uint8_t DQuadSpc_with_dsub_0_in_DPR_8Bits[] = {
 2471   const uint8_t DQuadSpc_with_dsub_2_in_DPR_8Bits[] = {
 2481   const uint8_t DQuadSpc_with_dsub_4_in_DPR_8Bits[] = {
 2491   const uint8_t DQuadBits[] = {
 2501   const uint8_t DQuad_with_ssub_0Bits[] = {
 2511   const uint8_t DQuad_with_ssub_2Bits[] = {
 2521   const uint8_t QQPRBits[] = {
 2531   const uint8_t DQuad_with_ssub_2_ssub_3_ssub_4_ssub_5_in_QPRBits[] = {
 2541   const uint8_t DQuad_with_ssub_4Bits[] = {
 2551   const uint8_t DQuad_with_ssub_6Bits[] = {
 2561   const uint8_t DQuad_with_dsub_0_in_DPR_8Bits[] = {
 2571   const uint8_t DQuad_with_qsub_0_in_MQPRBits[] = {
 2581   const uint8_t DQuad_with_ssub_0_and_DQuad_with_ssub_2_ssub_3_ssub_4_ssub_5_in_QPRBits[] = {
 2591   const uint8_t DQuad_with_dsub_1_in_DPR_8Bits[] = {
 2601   const uint8_t DQuad_with_qsub_1_in_MQPRBits[] = {
 2611   const uint8_t DQuad_with_ssub_2_ssub_3_ssub_4_ssub_5_in_MQPRBits[] = {
 2621   const uint8_t DQuad_with_dsub_2_in_DPR_8Bits[] = {
 2631   const uint8_t DQuad_with_ssub_6_and_DQuad_with_ssub_2_ssub_3_ssub_4_ssub_5_in_MQPRBits[] = {
 2641   const uint8_t DQuad_with_dsub_3_in_DPR_8Bits[] = {
 2651   const uint8_t DQuad_with_dsub_0_in_DPR_8_and_DQuad_with_ssub_2_ssub_3_ssub_4_ssub_5_in_MQPRBits[] = {
 2661   const uint8_t DQuad_with_qsub_0_in_QPR_8Bits[] = {
 2671   const uint8_t DQuad_with_qsub_1_in_QPR_8Bits[] = {
 2681   const uint8_t DQuad_with_ssub_2_ssub_3_ssub_4_ssub_5_in_QPR_8Bits[] = {
 2691   const uint8_t DQuad_with_dsub_3_in_DPR_8_and_DQuad_with_ssub_2_ssub_3_ssub_4_ssub_5_in_MQPRBits[] = {
 2701   const uint8_t QQQQPRBits[] = {
 2711   const uint8_t QQQQPR_with_ssub_0Bits[] = {
 2721   const uint8_t QQQQPR_with_ssub_4Bits[] = {
 2731   const uint8_t QQQQPR_with_ssub_8Bits[] = {
 2741   const uint8_t QQQQPR_with_ssub_12Bits[] = {
 2751   const uint8_t QQQQPR_with_dsub_0_in_DPR_8Bits[] = {
 2761   const uint8_t QQQQPR_with_dsub_2_in_DPR_8Bits[] = {
 2771   const uint8_t QQQQPR_with_dsub_4_in_DPR_8Bits[] = {
 2781   const uint8_t QQQQPR_with_dsub_6_in_DPR_8Bits[] = {
 8436   static const uint8_t RowMap[56] = {
 8439   static const uint8_t Rows[8][56] = {
 8457     uint8_t  RotateLeft;
 8566   static const uint8_t Table[122][56] = {
15786   static const uint8_t RUWeightTable[] = {
15843   static const uint8_t PressureLimitTable[] = {
15917   static const uint8_t RCSetStartTable[] = {
15927   static const uint8_t RUSetStartTable[] = {

   83 const BankedReg *lookupBankedRegByEncoding(uint8_t Encoding);
  183 const BankedReg *lookupBankedRegByEncoding(uint8_t Encoding) {
  185     uint8_t Encoding;
  225     uint8_t Encoding;

   56 enum SubtargetFeatureBits : uint8_t {
  356 static const uint8_t TiedAsmOperandTable[][3] = {
  424 static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][9] = {
  497   const uint8_t *Converter = ConversionTable[Kind];
  500   for (const uint8_t *p = Converter; *p; p+= 2) {
  567   const uint8_t *Converter = ConversionTable[Kind];
  568   for (const uint8_t *p = Converter; *p; p+= 2) {
 1010   const uint8_t *Converter = ConversionTable[Kind];
 1011   for (const uint8_t *p = Converter; *p; p+= 2) {
 1055 enum : uint8_t {
 1099     uint8_t ConvertFn;
 1100     uint8_t RequiredFeaturesIdx;
 1101     uint8_t Classes[3];
 1455     uint8_t OperandMask;
 1456     uint8_t Class;
 1457     uint8_t RequiredFeaturesIdx;

  504   static const uint8_t OpInfo1[] = {
 1018   static const uint8_t RegAsmOffsetNoRegAltName[] = {
 1031   static const uint8_t RegAsmOffsetptr[] = {

   61 static const uint8_t DecoderTable16[] = {
  364 static const uint8_t DecoderTable32[] = {
  575 static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
  581   const uint8_t *Ptr = DecodeTable;

  340   const uint8_t GPR8Bits[] = {
  350   const uint8_t GPR8loBits[] = {
  360   const uint8_t LD8Bits[] = {
  370   const uint8_t LD8loBits[] = {
  380   const uint8_t CCRBits[] = {
  390   const uint8_t DREGSBits[] = {
  400   const uint8_t DREGS_WITHOUT_YZ_WORKAROUNDBits[] = {
  410   const uint8_t DLDREGSBits[] = {
  420   const uint8_t DREGS_with_sub_hi_in_GPR8loBits[] = {
  430   const uint8_t DLDREGS_and_DREGS_WITHOUT_YZ_WORKAROUNDBits[] = {
  440   const uint8_t DLDREGS_with_sub_hi_in_LD8loBits[] = {
  450   const uint8_t IWREGSBits[] = {
  460   const uint8_t PTRREGSBits[] = {
  470   const uint8_t DREGS_WITHOUT_YZ_WORKAROUND_and_IWREGSBits[] = {
  480   const uint8_t PTRDISPREGSBits[] = {
  490   const uint8_t DREGS_WITHOUT_YZ_WORKAROUND_and_PTRREGSBits[] = {
  500   const uint8_t GPRSPBits[] = {
  510   const uint8_t ZREGBits[] = {
 1436   static const uint8_t Rows[1][2] = {
 1447     uint8_t  RotateLeft;
 1486   static const uint8_t Table[18][2] = {
 1630   static const uint8_t PressureLimitTable[] = {
 1659   static const uint8_t RCSetStartTable[] = {
 1669   static const uint8_t RUSetStartTable[] = {

   48 enum SubtargetFeatureBits : uint8_t {
  164 static const uint8_t TiedAsmOperandTable[][3] = {
  212 static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][9] = {
  269   const uint8_t *Converter = ConversionTable[Kind];
  272   for (const uint8_t *p = Converter; *p; p+= 2) {
  306   const uint8_t *Converter = ConversionTable[Kind];
  307   for (const uint8_t *p = Converter; *p; p+= 2) {
  698   const uint8_t *Converter = ConversionTable[Kind];
  699   for (const uint8_t *p = Converter; *p; p+= 2) {
  732 enum : uint8_t {
  742     uint8_t Mnemonic;
  744     uint8_t ConvertFn;
  745     uint8_t RequiredFeaturesIdx;
  746     uint8_t Classes[13];

  358   static const uint8_t OpInfo1[] = {
 1049   static const uint8_t RegAsmOffset[] = {

   61 static const uint8_t DecoderTableBPF64[] = {
  307 static const uint8_t DecoderTableBPFALU3264[] = {
  512 static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
  518   const uint8_t *Ptr = DecodeTable;

  632 enum SubtargetFeatureBits : uint8_t {
  649 enum : uint8_t {
  661   static uint8_t RequiredFeaturesRefs[] = {

  186   const uint8_t GPR32Bits[] = {
  196   const uint8_t GPRBits[] = {
  529   static const uint8_t Rows[1][1] = {
  540     uint8_t  RotateLeft;
  577   static const uint8_t Table[2][1] = {
  630   static const uint8_t PressureLimitTable[] = {
  645   static const uint8_t RCSetStartTable[] = {
  655   static const uint8_t RUSetStartTable[] = {

   48 enum SubtargetFeatureBits : uint8_t {
 1166 static const uint8_t TiedAsmOperandTable[][3] = {
 1651 static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][13] = {
 2546   const uint8_t *Converter = ConversionTable[Kind];
 2549   for (const uint8_t *p = Converter; *p; p+= 2) {
 2610   const uint8_t *Converter = ConversionTable[Kind];
 2611   for (const uint8_t *p = Converter; *p; p+= 2) {
 7481   const uint8_t *Converter = ConversionTable[Kind];
 7482   for (const uint8_t *p = Converter; *p; p+= 2) {
 7521 enum : uint8_t {
 7556     uint8_t RequiredFeaturesIdx;

 6089   static const uint8_t OpInfo2[] = {

72432   uint8_t NV = ~N->getZExtValue();
72980   uint8_t NV = ~N->getZExtValue();
73001   uint8_t V = N->getZExtValue();

   61 static const uint8_t DecoderTable32[] = {
 5439 static const uint8_t DecoderTableEXT_mmvec32[] = {
 7797 static const uint8_t DecoderTableMustExtend32[] = {
 8301 static const uint8_t DecoderTableSUBINSN_A32[] = {
 8396 static const uint8_t DecoderTableSUBINSN_L132[] = {
 8408 static const uint8_t DecoderTableSUBINSN_L232[] = {
 8468 static const uint8_t DecoderTableSUBINSN_S132[] = {
 8480 static const uint8_t DecoderTableSUBINSN_S232[] = {
12199 static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
12205   const uint8_t *Ptr = DecodeTable;

11548 enum SubtargetFeatureBits : uint8_t {
11621 enum : uint8_t {
11655   static uint8_t RequiredFeaturesRefs[] = {

 1009   const uint8_t UsrBitsBits[] = {
 1019   const uint8_t GuestRegsBits[] = {
 1029   const uint8_t IntRegsBits[] = {
 1039   const uint8_t CtrRegsBits[] = {
 1049   const uint8_t GeneralSubRegsBits[] = {
 1059   const uint8_t V62RegsBits[] = {
 1069   const uint8_t IntRegsLow8Bits[] = {
 1079   const uint8_t CtrRegs_and_V62RegsBits[] = {
 1089   const uint8_t PredRegsBits[] = {
 1099   const uint8_t V62Regs_with_isub_hiBits[] = {
 1109   const uint8_t ModRegsBits[] = {
 1119   const uint8_t CtrRegs_with_subreg_overflowBits[] = {
 1129   const uint8_t V65RegsBits[] = {
 1139   const uint8_t DoubleRegsBits[] = {
 1149   const uint8_t GuestRegs64Bits[] = {
 1159   const uint8_t CtrRegs64Bits[] = {
 1169   const uint8_t GeneralDoubleLow8RegsBits[] = {
 1179   const uint8_t DoubleRegs_with_isub_hi_in_IntRegsLow8Bits[] = {
 1189   const uint8_t CtrRegs64_and_V62RegsBits[] = {
 1199   const uint8_t CtrRegs64_with_isub_hi_in_ModRegsBits[] = {
 1209   const uint8_t HvxVRBits[] = {
 1219   const uint8_t HvxQRBits[] = {
 1229   const uint8_t HvxVR_and_V65RegsBits[] = {
 1239   const uint8_t HvxWRBits[] = {
 1249   const uint8_t HvxVQRBits[] = {
 3178   static const uint8_t RowMap[9] = {
 3181   static const uint8_t Rows[2][9] = {
 3193     uint8_t  RotateLeft;
 3244   static const uint8_t Table[25][9] = {
 3596   static const uint8_t PressureLimitTable[] = {
 3622   static const uint8_t RCSetStartTable[] = {
 3632   static const uint8_t RUSetStartTable[] = {

   56 enum SubtargetFeatureBits : uint8_t {
  212 static const uint8_t TiedAsmOperandTable[][3] = { /* empty  */ {0, 0, 0} };
  276 static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][9] = {
  345   const uint8_t *Converter = ConversionTable[Kind];
  348   for (const uint8_t *p = Converter; *p; p+= 2) {
  424   const uint8_t *Converter = ConversionTable[Kind];
  425   for (const uint8_t *p = Converter; *p; p+= 2) {
  864   const uint8_t *Converter = ConversionTable[Kind];
  865   for (const uint8_t *p = Converter; *p; p+= 2) {
  902 enum : uint8_t {
  912     uint8_t Mnemonic;
  914     uint8_t ConvertFn;
  915     uint8_t RequiredFeaturesIdx;
  916     uint8_t Classes[7];
 1238     uint8_t Mnemonic;
 1239     uint8_t OperandMask;
 1240     uint8_t Class;
 1241     uint8_t RequiredFeaturesIdx;

  358   static const uint8_t OpInfo1[] = {
  885   static const uint8_t RegAsmOffset[] = {

   61 static const uint8_t DecoderTableLanai32[] = {
  453 static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
  459   const uint8_t *Ptr = DecodeTable;

  269   const uint8_t GPRBits[] = {
  279   const uint8_t GPR_with_sub_32Bits[] = {
  289   const uint8_t CCRBits[] = {
  749   static const uint8_t Rows[1][1] = {
  760     uint8_t  RotateLeft;
  797   static const uint8_t Table[3][1] = {
  855   static const uint8_t PressureLimitTable[] = {
  871   static const uint8_t RCSetStartTable[] = {
  881   static const uint8_t RUSetStartTable[] = {

   48 enum SubtargetFeatureBits : uint8_t {
  160 static const uint8_t TiedAsmOperandTable[][3] = {
  235 static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][9] = {
  330   const uint8_t *Converter = ConversionTable[Kind];
  333   for (const uint8_t *p = Converter; *p; p+= 2) {
  394   const uint8_t *Converter = ConversionTable[Kind];
  395   for (const uint8_t *p = Converter; *p; p+= 2) {
  632   const uint8_t *Converter = ConversionTable[Kind];
  633   for (const uint8_t *p = Converter; *p; p+= 2) {
  673 enum : uint8_t {
  685     uint8_t ConvertFn;
  686     uint8_t RequiredFeaturesIdx;
  687     uint8_t Classes[2];

  753   static const uint8_t RegAsmOffset[] = {

   61 static const uint8_t DecoderTable16[] = {
  139 static const uint8_t DecoderTable32[] = {
  165 static const uint8_t DecoderTableAlpha16[] = {
  245 static const uint8_t DecoderTableAlpha32[] = {
  323 static const uint8_t DecoderTableBeta16[] = {
  401 static const uint8_t DecoderTableBeta32[] = {
  479 static const uint8_t DecoderTableDelta16[] = {
  610 static const uint8_t DecoderTableDelta32[] = {
  732 static const uint8_t DecoderTableGamma32[] = {
  887 static const uint8_t DecoderTableGamma48[] = {
 1330 static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
 1336   const uint8_t *Ptr = DecodeTable;

  220   const uint8_t GR8Bits[] = {
  230   const uint8_t GR16Bits[] = {
  462   static const uint8_t Rows[1][1] = {
  473     uint8_t  RotateLeft;
  510   static const uint8_t Table[2][1] = {
  563   static const uint8_t PressureLimitTable[] = {
  578   static const uint8_t RCSetStartTable[] = {
  588   static const uint8_t RUSetStartTable[] = {

  106 enum SubtargetFeatureBits : uint8_t {
  234 static const uint8_t TiedAsmOperandTable[][3] = {
  655 static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][11] = {
 1326   const uint8_t *Converter = ConversionTable[Kind];
 1329   for (const uint8_t *p = Converter; *p; p+= 2) {
 1564   const uint8_t *Converter = ConversionTable[Kind];
 1565   for (const uint8_t *p = Converter; *p; p+= 2) {
 4881   const uint8_t *Converter = ConversionTable[Kind];
 4882   for (const uint8_t *p = Converter; *p; p+= 2) {
 5100 enum : uint8_t {
 5391     uint8_t RequiredFeaturesIdx;
 5392     uint8_t Classes[8];
 8273     uint8_t OperandMask;
 8274     uint8_t Class;
 8275     uint8_t RequiredFeaturesIdx;

   61 static const uint8_t DecoderTable16[] = {
  194 static const uint8_t DecoderTable32[] = {
  300 static const uint8_t DecoderTableCOP3_32[] = {
  318 static const uint8_t DecoderTableCnMips32[] = {
  426 static const uint8_t DecoderTableMicroMips16[] = {
  569 static const uint8_t DecoderTableMicroMips32[] = {
 1962 static const uint8_t DecoderTableMicroMipsDSP32[] = {
 1974 static const uint8_t DecoderTableMicroMipsFP6432[] = {
 2047 static const uint8_t DecoderTableMicroMipsR616[] = {
 2149 static const uint8_t DecoderTableMicroMipsR632[] = {
 2804 static const uint8_t DecoderTableMicroMipsR6_Ambiguous32[] = {
 2828 static const uint8_t DecoderTableMips32[] = {
 6207 static const uint8_t DecoderTableMips32_64_PTR6432[] = {
 6223 static const uint8_t DecoderTableMips32r6_64r632[] = {
 6722 static const uint8_t DecoderTableMips32r6_64r6_Ambiguous32[] = {
 6764 static const uint8_t DecoderTableMips32r6_64r6_BranchZero32[] = {
 6776 static const uint8_t DecoderTableMips32r6_64r6_GP6432[] = {
 6830 static const uint8_t DecoderTableMips32r6_64r6_PTR6432[] = {
 6844 static const uint8_t DecoderTableMips6432[] = {
 7095 static const uint8_t DecoderTableMipsDSP32[] = {
 7107 static const uint8_t DecoderTableMipsFP6432[] = {
10310 static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
10316   const uint8_t *Ptr = DecodeTable;

   35 enum SubtargetFeatureBits : uint8_t {

 1921   const uint8_t MSA128F16Bits[] = {
 1931   const uint8_t CCRBits[] = {
 1941   const uint8_t COP0Bits[] = {
 1951   const uint8_t COP2Bits[] = {
 1961   const uint8_t COP3Bits[] = {
 1971   const uint8_t DSPRBits[] = {
 1981   const uint8_t FGR32Bits[] = {
 1991   const uint8_t FGRCCBits[] = {
 2001   const uint8_t GPR32Bits[] = {
 2011   const uint8_t HWRegsBits[] = {
 2021   const uint8_t MSACtrlBits[] = {
 2031   const uint8_t GPR32NONZEROBits[] = {
 2041   const uint8_t CPU16RegsPlusSPBits[] = {
 2051   const uint8_t CPU16RegsBits[] = {
 2061   const uint8_t FCCBits[] = {
 2071   const uint8_t GPRMM16Bits[] = {
 2081   const uint8_t GPRMM16MovePBits[] = {
 2091   const uint8_t GPRMM16ZeroBits[] = {
 2101   const uint8_t CPU16Regs_and_GPRMM16ZeroBits[] = {
 2111   const uint8_t GPR32NONZERO_and_GPRMM16MovePBits[] = {
 2121   const uint8_t GPRMM16MovePPairSecondBits[] = {
 2131   const uint8_t CPU16Regs_and_GPRMM16MovePBits[] = {
 2141   const uint8_t GPRMM16MoveP_and_GPRMM16ZeroBits[] = {
 2151   const uint8_t HI32DSPBits[] = {
 2161   const uint8_t LO32DSPBits[] = {
 2171   const uint8_t CPU16Regs_and_GPRMM16MovePPairSecondBits[] = {
 2181   const uint8_t GPRMM16MovePPairFirstBits[] = {
 2191   const uint8_t GPRMM16MoveP_and_CPU16Regs_and_GPRMM16ZeroBits[] = {
 2201   const uint8_t GPRMM16MovePPairFirst_and_GPRMM16MovePPairSecondBits[] = {
 2211   const uint8_t CPURARegBits[] = {
 2221   const uint8_t CPUSPRegBits[] = {
 2231   const uint8_t DSPCCBits[] = {
 2241   const uint8_t GP32Bits[] = {
 2251   const uint8_t GPR32ZEROBits[] = {
 2261   const uint8_t HI32Bits[] = {
 2271   const uint8_t LO32Bits[] = {
 2281   const uint8_t SP32Bits[] = {
 2291   const uint8_t FGR64Bits[] = {
 2301   const uint8_t GPR64Bits[] = {
 2311   const uint8_t GPR64_with_sub_32_in_GPR32NONZEROBits[] = {
 2321   const uint8_t AFGR64Bits[] = {
 2331   const uint8_t GPR64_with_sub_32_in_CPU16RegsPlusSPBits[] = {
 2341   const uint8_t GPR64_with_sub_32_in_CPU16RegsBits[] = {
 2351   const uint8_t GPR64_with_sub_32_in_GPRMM16MovePBits[] = {
 2361   const uint8_t GPR64_with_sub_32_in_GPRMM16ZeroBits[] = {
 2371   const uint8_t GPR64_with_sub_32_in_CPU16Regs_and_GPRMM16ZeroBits[] = {
 2381   const uint8_t GPR64_with_sub_32_in_GPR32NONZERO_and_GPRMM16MovePBits[] = {
 2391   const uint8_t GPR64_with_sub_32_in_GPRMM16MovePPairSecondBits[] = {
 2401   const uint8_t ACC64DSPBits[] = {
 2411   const uint8_t GPR64_with_sub_32_in_CPU16Regs_and_GPRMM16MovePBits[] = {
 2421   const uint8_t GPR64_with_sub_32_in_GPRMM16MoveP_and_GPRMM16ZeroBits[] = {
 2431   const uint8_t GPR64_with_sub_32_in_CPU16Regs_and_GPRMM16MovePPairSecondBits[] = {
 2441   const uint8_t GPR64_with_sub_32_in_GPRMM16MovePPairFirstBits[] = {
 2451   const uint8_t GPR64_with_sub_32_in_GPRMM16MoveP_and_CPU16Regs_and_GPRMM16ZeroBits[] = {
 2461   const uint8_t OCTEON_MPLBits[] = {
 2471   const uint8_t OCTEON_PBits[] = {
 2481   const uint8_t GPR64_with_sub_32_in_GPRMM16MovePPairFirst_and_GPRMM16MovePPairSecondBits[] = {
 2491   const uint8_t ACC64Bits[] = {
 2501   const uint8_t GP64Bits[] = {
 2511   const uint8_t GPR64_with_sub_32_in_CPURARegBits[] = {
 2521   const uint8_t GPR64_with_sub_32_in_GPR32ZEROBits[] = {
 2531   const uint8_t HI64Bits[] = {
 2541   const uint8_t LO64Bits[] = {
 2551   const uint8_t SP64Bits[] = {
 2561   const uint8_t MSA128BBits[] = {
 2571   const uint8_t MSA128DBits[] = {
 2581   const uint8_t MSA128HBits[] = {
 2591   const uint8_t MSA128WBits[] = {
 2601   const uint8_t MSA128WEvensBits[] = {
 2611   const uint8_t ACC128Bits[] = {
 6157   static const uint8_t RowMap[11] = {
 6160   static const uint8_t Rows[2][11] = {
 6172     uint8_t  RotateLeft;
 6225   static const uint8_t Table[70][11] = {
 7269   static const uint8_t PressureLimitTable[] = {
 7314   static const uint8_t RCSetStartTable[] = {
 7324   static const uint8_t RUSetStartTable[] = {

  472   const uint8_t Int1RegsBits[] = {
  482   const uint8_t Float16RegsBits[] = {
  492   const uint8_t Int16RegsBits[] = {
  502   const uint8_t SpecialRegsBits[] = {
  512   const uint8_t Float16x2RegsBits[] = {
  522   const uint8_t Float32ArgRegsBits[] = {
  532   const uint8_t Float32RegsBits[] = {
  542   const uint8_t Int32ArgRegsBits[] = {
  552   const uint8_t Int32RegsBits[] = {
  562   const uint8_t Float64ArgRegsBits[] = {
  572   const uint8_t Float64RegsBits[] = {
  582   const uint8_t Int64ArgRegsBits[] = {
  592   const uint8_t Int64RegsBits[] = {
 1240   static const uint8_t PressureLimitTable[] = {
 1279   static const uint8_t RCSetStartTable[] = {
 1289   static const uint8_t RUSetStartTable[] = {

   48 enum SubtargetFeatureBits : uint8_t {
  106 static const uint8_t TiedAsmOperandTable[][3] = {
  857 static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][13] = {
 2082   const uint8_t *Converter = ConversionTable[Kind];
 2085   for (const uint8_t *p = Converter; *p; p+= 2) {
 2482   const uint8_t *Converter = ConversionTable[Kind];
 2483   for (const uint8_t *p = Converter; *p; p+= 2) {
 4120   const uint8_t *Converter = ConversionTable[Kind];
 4121   for (const uint8_t *p = Converter; *p; p+= 2) {
 4431 enum : uint8_t {
 4444     uint8_t RequiredFeaturesIdx;
 4445     uint8_t Classes[6];

   61 static const uint8_t DecoderTable32[] = {
 3421 static const uint8_t DecoderTableQPX32[] = {
 3843 static const uint8_t DecoderTableSPE32[] = {
 6560 static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
 6566   const uint8_t *Ptr = DecodeTable;

 6252 enum SubtargetFeatureBits : uint8_t {
 6269 enum : uint8_t {
 6281   static uint8_t RequiredFeaturesRefs[] = {

 1340   const uint8_t VSSRCBits[] = {
 1350   const uint8_t GPRCBits[] = {
 1360   const uint8_t GPRC_NOR0Bits[] = {
 1370   const uint8_t GPRC_and_GPRC_NOR0Bits[] = {
 1380   const uint8_t CRBITRCBits[] = {
 1390   const uint8_t F4RCBits[] = {
 1400   const uint8_t CRRCBits[] = {
 1410   const uint8_t CARRYRCBits[] = {
 1420   const uint8_t CTRRCBits[] = {
 1430   const uint8_t VRSAVERCBits[] = {
 1440   const uint8_t SPILLTOVSRRCBits[] = {
 1450   const uint8_t VSFRCBits[] = {
 1460   const uint8_t G8RCBits[] = {
 1470   const uint8_t G8RC_NOX0Bits[] = {
 1480   const uint8_t SPILLTOVSRRC_and_VSFRCBits[] = {
 1490   const uint8_t G8RC_and_G8RC_NOX0Bits[] = {
 1500   const uint8_t F8RCBits[] = {
 1510   const uint8_t SPERCBits[] = {
 1520   const uint8_t VFRCBits[] = {
 1530   const uint8_t SPERC_with_sub_32_in_GPRC_NOR0Bits[] = {
 1540   const uint8_t SPILLTOVSRRC_and_VFRCBits[] = {
 1550   const uint8_t SPILLTOVSRRC_and_F4RCBits[] = {
 1560   const uint8_t CTRRC8Bits[] = {
 1570   const uint8_t VSRCBits[] = {
 1580   const uint8_t VSRC_with_sub_64_in_SPILLTOVSRRCBits[] = {
 1590   const uint8_t QSRCBits[] = {
 1600   const uint8_t VRRCBits[] = {
 1610   const uint8_t VSLRCBits[] = {
 1620   const uint8_t VRRC_with_sub_64_in_SPILLTOVSRRCBits[] = {
 1630   const uint8_t QSRC_with_sub_64_in_SPILLTOVSRRCBits[] = {
 1640   const uint8_t VSLRC_with_sub_64_in_SPILLTOVSRRCBits[] = {
 1650   const uint8_t QBRCBits[] = {
 1660   const uint8_t QFRCBits[] = {
 1670   const uint8_t QBRC_with_sub_64_in_SPILLTOVSRRCBits[] = {
 5165   static const uint8_t Rows[1][6] = {
 5176     uint8_t  RotateLeft;
 5223   static const uint8_t Table[34][6] = {
 5589   static const uint8_t PressureLimitTable[] = {
 5628   static const uint8_t RCSetStartTable[] = {
 5638   static const uint8_t RUSetStartTable[] = {

   84 enum SubtargetFeatureBits : uint8_t {
  626 static const uint8_t TiedAsmOperandTable[][3] = {
  758 static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][11] = {
  951   const uint8_t *Converter = ConversionTable[Kind];
  954   for (const uint8_t *p = Converter; *p; p+= 2) {
 1042   const uint8_t *Converter = ConversionTable[Kind];
 1043   for (const uint8_t *p = Converter; *p; p+= 2) {
 1768   const uint8_t *Converter = ConversionTable[Kind];
 1769   for (const uint8_t *p = Converter; *p; p+= 2) {
 1850 enum : uint8_t {
 1894     uint8_t ConvertFn;
 1895     uint8_t RequiredFeaturesIdx;
 1896     uint8_t Classes[5];
 2591     uint8_t OperandMask;
 2592     uint8_t Class;
 2593     uint8_t RequiredFeaturesIdx;

  788   static const uint8_t OpInfo1[] = {
 1498   static const uint8_t RegAsmOffsetABIRegAltName[] = {
 1575   static const uint8_t RegAsmOffsetNoRegAltName[] = {

   61 static const uint8_t DecoderTable16[] = {
  240 static const uint8_t DecoderTable32[] = {
 1098 static const uint8_t DecoderTableRISCV32Only_16[] = {
 1736 static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
 1742   const uint8_t *Ptr = DecodeTable;

   35 enum SubtargetFeatureBits : uint8_t {

  475   const uint8_t FPR32Bits[] = {
  485   const uint8_t GPRBits[] = {
  495   const uint8_t GPRNoX0Bits[] = {
  505   const uint8_t GPRNoX0X2Bits[] = {
  515   const uint8_t GPRTCBits[] = {
  525   const uint8_t FPR32CBits[] = {
  535   const uint8_t GPRCBits[] = {
  545   const uint8_t GPRC_and_GPRTCBits[] = {
  555   const uint8_t GPRX0Bits[] = {
  565   const uint8_t SPBits[] = {
  575   const uint8_t FPR64Bits[] = {
  585   const uint8_t FPR64CBits[] = {
 1603   static const uint8_t Rows[1][1] = {
 1614     uint8_t  RotateLeft;
 1651   static const uint8_t Table[12][1] = {
 1750   static const uint8_t PressureLimitTable[] = {
 1774   static const uint8_t RCSetStartTable[] = {
 1784   static const uint8_t RUSetStartTable[] = {

   56 enum SubtargetFeatureBits : uint8_t {
  371 static const uint8_t TiedAsmOperandTable[][3] = {
  797 static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][11] = {
 1570   const uint8_t *Converter = ConversionTable[Kind];
 1573   for (const uint8_t *p = Converter; *p; p+= 2) {
 1670   const uint8_t *Converter = ConversionTable[Kind];
 1671   for (const uint8_t *p = Converter; *p; p+= 2) {
 2335   const uint8_t *Converter = ConversionTable[Kind];
 2336   for (const uint8_t *p = Converter; *p; p+= 2) {
 2434 enum : uint8_t {
 2457     uint8_t RequiredFeaturesIdx;
 2458     uint8_t Classes[6];
 4335     uint8_t OperandMask;
 4336     uint8_t Class;
 4337     uint8_t RequiredFeaturesIdx;

   61 static const uint8_t DecoderTableSparc32[] = {
 1733 static const uint8_t DecoderTableSparcV832[] = {
 1748 static const uint8_t DecoderTableSparcV932[] = {
 2358 static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
 2364   const uint8_t *Ptr = DecodeTable;

 1686 enum SubtargetFeatureBits : uint8_t {
 1727 enum : uint8_t {
 1749   static uint8_t RequiredFeaturesRefs[] = {

 1095   const uint8_t FCCRegsBits[] = {
 1105   const uint8_t ASRRegsBits[] = {
 1115   const uint8_t CoprocRegsBits[] = {
 1125   const uint8_t FPRegsBits[] = {
 1135   const uint8_t IntRegsBits[] = {
 1145   const uint8_t DFPRegsBits[] = {
 1155   const uint8_t I64RegsBits[] = {
 1165   const uint8_t CoprocPairBits[] = {
 1175   const uint8_t IntPairBits[] = {
 1185   const uint8_t LowDFPRegsBits[] = {
 1195   const uint8_t PRRegsBits[] = {
 1205   const uint8_t QFPRegsBits[] = {
 1215   const uint8_t LowQFPRegsBits[] = {
 2490   static const uint8_t RowMap[6] = {
 2493   static const uint8_t Rows[2][6] = {
 2505     uint8_t  RotateLeft;
 2550   static const uint8_t Table[13][6] = {
 2689   static const uint8_t RUWeightTable[] = {
 2717   static const uint8_t PressureLimitTable[] = {
 2739   static const uint8_t RCSetStartTable[] = {
 2749   static const uint8_t RUSetStartTable[] = {

   56 enum SubtargetFeatureBits : uint8_t {
  155 static const uint8_t TiedAsmOperandTable[][3] = {
  568 static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][13] = {
 1343   const uint8_t *Converter = ConversionTable[Kind];
 1346   for (const uint8_t *p = Converter; *p; p+= 2) {
 1398   const uint8_t *Converter = ConversionTable[Kind];
 1399   for (const uint8_t *p = Converter; *p; p+= 2) {
 2329   const uint8_t *Converter = ConversionTable[Kind];
 2330   for (const uint8_t *p = Converter; *p; p+= 2) {
 2671 enum : uint8_t {
 2752     uint8_t RequiredFeaturesIdx;
 2753     uint8_t Classes[6];
 5530     uint8_t OperandMask;
 5531     uint8_t Class;
 5532     uint8_t RequiredFeaturesIdx;

 8359   static const uint8_t OpInfo2[] = {

   61 static const uint8_t DecoderTable16[] = {
  237 static const uint8_t DecoderTable32[] = {
 2312 static const uint8_t DecoderTable48[] = {
10731 static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
10737   const uint8_t *Ptr = DecodeTable;

 8738 enum SubtargetFeatureBits : uint8_t {
 8895 enum : uint8_t {
 8977   static uint8_t RequiredFeaturesRefs[] = {

  860   const uint8_t GRX32BitBits[] = {
  870   const uint8_t VR32BitBits[] = {
  880   const uint8_t AR32BitBits[] = {
  890   const uint8_t FP32BitBits[] = {
  900   const uint8_t GR32BitBits[] = {
  910   const uint8_t GRH32BitBits[] = {
  920   const uint8_t ADDR32BitBits[] = {
  930   const uint8_t CCRBits[] = {
  940   const uint8_t FPCRegsBits[] = {
  950   const uint8_t AnyRegBitBits[] = {
  960   const uint8_t AnyRegBit_with_subreg_h32_in_FP32BitBits[] = {
  970   const uint8_t VR64BitBits[] = {
  980   const uint8_t AnyRegBit_with_subreg_h64Bits[] = {
  990   const uint8_t CR64BitBits[] = {
 1000   const uint8_t FP64BitBits[] = {
 1010   const uint8_t GR64BitBits[] = {
 1020   const uint8_t ADDR64BitBits[] = {
 1030   const uint8_t VR128BitBits[] = {
 1040   const uint8_t VF128BitBits[] = {
 1050   const uint8_t FP128BitBits[] = {
 1060   const uint8_t GR128BitBits[] = {
 1070   const uint8_t ADDR128BitBits[] = {
 2576   static const uint8_t RowMap[6] = {
 2579   static const uint8_t Rows[2][6] = {
 2591     uint8_t  RotateLeft;
 2637   static const uint8_t Table[22][6] = {
 2884   static const uint8_t PressureLimitTable[] = {
 2905   static const uint8_t RCSetStartTable[] = {
 2915   static const uint8_t RUSetStartTable[] = {

   48 enum SubtargetFeatureBits : uint8_t {
   91 static const uint8_t TiedAsmOperandTable[][3] = { /* empty  */ {0, 0, 0} };
  125 static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][33] = {
  160   const uint8_t *Converter = ConversionTable[Kind];
  163   for (const uint8_t *p = Converter; *p; p+= 2) {
  200   const uint8_t *Converter = ConversionTable[Kind];
  201   for (const uint8_t *p = Converter; *p; p+= 2) {
  386   const uint8_t *Converter = ConversionTable[Kind];
  387   for (const uint8_t *p = Converter; *p; p+= 2) {
  521 enum : uint8_t {
  549     uint8_t ConvertFn;
  550     uint8_t RequiredFeaturesIdx;
  551     uint8_t Classes[16];

 2317   static const uint8_t RegAsmOffset[] = {

   15 enum EntryType : uint8_t { ET_Unused, ET_Prefix, ET_Instruction };
   20   uint8_t NumOperands;
 1492 const uint8_t OperandTable[] = {
 1533 struct { uint8_t Prefix; const WebAssemblyInstruction *Table; }

  138   const uint8_t EXNREFBits[] = {
  148   const uint8_t I32Bits[] = {
  158   const uint8_t F32Bits[] = {
  168   const uint8_t I64Bits[] = {
  178   const uint8_t F64Bits[] = {
  188   const uint8_t V128Bits[] = {
  507   static const uint8_t PressureLimitTable[] = {
  532   static const uint8_t RCSetStartTable[] = {
  542   static const uint8_t RUSetStartTable[] = {

   50 enum SubtargetFeatureBits : uint8_t {
 2137 static const uint8_t TiedAsmOperandTable[][3] = {
 3108 static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][13] = {
 4941   const uint8_t *Converter = ConversionTable[Kind];
 4944   for (const uint8_t *p = Converter; *p; p+= 2) {
 5068   const uint8_t *Converter = ConversionTable[Kind];
 5069   for (const uint8_t *p = Converter; *p; p+= 2) {
 7577   const uint8_t *Converter = ConversionTable[Kind];
 7578   for (const uint8_t *p = Converter; *p; p+= 2) {
 7918 enum : uint8_t {
 7941     uint8_t RequiredFeaturesIdx;
 7942     uint8_t Classes[9];

32162   static const uint8_t OpInfo2[] = {

254745   uint8_t Imm = N->getZExtValue();
254780   uint8_t Imm = X86::getSwappedVCMPImm(N->getZExtValue() & 0x1f);
254788   uint8_t SSECC = X86::getVPCMPImmForCond(CC);
254796   uint8_t SSECC = X86::getVPCMPImmForCond(CC);
254864   uint8_t Imm = N->getZExtValue();
254866   uint8_t NewImm = Imm & 0xa5;
254878   uint8_t Imm = N->getZExtValue();
254880   uint8_t NewImm = Imm & 0x99;
254892   uint8_t Imm = N->getZExtValue();
254894   uint8_t NewImm = Imm & 0xc3;
254906   uint8_t Imm = N->getZExtValue();
254908   uint8_t NewImm = Imm & 0x81;
254922   uint8_t Imm = N->getZExtValue();
254924   uint8_t NewImm = Imm & 0x81;
254937   uint8_t Imm = N->getZExtValue() & 0x7;
254945   uint8_t Imm = N->getZExtValue() & 0xff;
254952   uint8_t Imm = N->getZExtValue() & 0x0f;
254959   uint8_t Imm = N->getZExtValue();
254960   uint8_t NewImm = 0;
254971   uint8_t Imm = N->getZExtValue();
254972   uint8_t NewImm = 0;
254983   uint8_t Imm = N->getZExtValue();
254984   uint8_t NewImm = 0;
254995   uint8_t Imm = N->getZExtValue();
254996   uint8_t NewImm = 0;
255007   uint8_t Imm = N->getZExtValue();
255008   uint8_t NewImm = 0;
255019   uint8_t Imm = N->getZExtValue();
255020   uint8_t NewImm = 0;
255031   uint8_t Imm = N->getZExtValue() & 0x03;

68347 static const uint8_t x86DisassemblerContexts[8192] = {

   35 enum SubtargetFeatureBits : uint8_t {

 1317   const uint8_t GR8Bits[] = {
 1327   const uint8_t GRH8Bits[] = {
 1337   const uint8_t GR8_NOREXBits[] = {
 1347   const uint8_t GR8_ABCD_HBits[] = {
 1357   const uint8_t GR8_ABCD_LBits[] = {
 1367   const uint8_t GRH16Bits[] = {
 1377   const uint8_t GR16Bits[] = {
 1387   const uint8_t GR16_NOREXBits[] = {
 1397   const uint8_t VK1Bits[] = {
 1407   const uint8_t VK16Bits[] = {
 1417   const uint8_t VK2Bits[] = {
 1427   const uint8_t VK4Bits[] = {
 1437   const uint8_t VK8Bits[] = {
 1447   const uint8_t VK16WMBits[] = {
 1457   const uint8_t VK1WMBits[] = {
 1467   const uint8_t VK2WMBits[] = {
 1477   const uint8_t VK4WMBits[] = {
 1487   const uint8_t VK8WMBits[] = {
 1497   const uint8_t SEGMENT_REGBits[] = {
 1507   const uint8_t GR16_ABCDBits[] = {
 1517   const uint8_t FPCCRBits[] = {
 1527   const uint8_t VK16PAIRBits[] = {
 1537   const uint8_t VK1PAIRBits[] = {
 1547   const uint8_t VK2PAIRBits[] = {
 1557   const uint8_t VK4PAIRBits[] = {
 1567   const uint8_t VK8PAIRBits[] = {
 1577   const uint8_t VK16PAIR_with_sub_mask_0_in_VK16WMBits[] = {
 1587   const uint8_t FR32XBits[] = {
 1597   const uint8_t LOW32_ADDR_ACCESS_RBPBits[] = {
 1607   const uint8_t LOW32_ADDR_ACCESSBits[] = {
 1617   const uint8_t LOW32_ADDR_ACCESS_RBP_with_sub_8bitBits[] = {
 1627   const uint8_t DEBUG_REGBits[] = {
 1637   const uint8_t FR32Bits[] = {
 1647   const uint8_t GR32Bits[] = {
 1657   const uint8_t GR32_NOSPBits[] = {
 1667   const uint8_t LOW32_ADDR_ACCESS_RBP_with_sub_16bit_in_GR16_NOREXBits[] = {
 1677   const uint8_t GR32_NOREXBits[] = {
 1687   const uint8_t VK32Bits[] = {
 1697   const uint8_t GR32_NOREX_NOSPBits[] = {
 1707   const uint8_t RFP32Bits[] = {
 1717   const uint8_t VK32WMBits[] = {
 1727   const uint8_t GR32_ABCDBits[] = {
 1737   const uint8_t GR32_TCBits[] = {
 1747   const uint8_t GR32_ABCD_and_GR32_TCBits[] = {
 1757   const uint8_t GR32_ADBits[] = {
 1767   const uint8_t GR32_BPSPBits[] = {
 1777   const uint8_t GR32_BSIBits[] = {
 1787   const uint8_t GR32_CBBits[] = {
 1797   const uint8_t GR32_DCBits[] = {
 1807   const uint8_t GR32_DIBPBits[] = {
 1817   const uint8_t GR32_SIDIBits[] = {
 1827   const uint8_t LOW32_ADDR_ACCESS_RBP_with_sub_32bitBits[] = {
 1837   const uint8_t CCRBits[] = {
 1847   const uint8_t DFCCRBits[] = {
 1857   const uint8_t GR32_ABCD_and_GR32_BSIBits[] = {
 1867   const uint8_t GR32_AD_and_GR32_DCBits[] = {
 1877   const uint8_t GR32_BPSP_and_GR32_DIBPBits[] = {
 1887   const uint8_t GR32_BPSP_and_GR32_TCBits[] = {
 1897   const uint8_t GR32_BSI_and_GR32_SIDIBits[] = {
 1907   const uint8_t GR32_CB_and_GR32_DCBits[] = {
 1917   const uint8_t GR32_DIBP_and_GR32_SIDIBits[] = {
 1927   const uint8_t LOW32_ADDR_ACCESS_RBP_with_sub_8bit_with_sub_32bitBits[] = {
 1937   const uint8_t LOW32_ADDR_ACCESS_with_sub_32bitBits[] = {
 1947   const uint8_t RFP64Bits[] = {
 1957   const uint8_t FR64XBits[] = {
 1967   const uint8_t GR64Bits[] = {
 1977   const uint8_t CONTROL_REGBits[] = {
 1987   const uint8_t FR64Bits[] = {
 1997   const uint8_t GR64_with_sub_8bitBits[] = {
 2007   const uint8_t GR64_NOSPBits[] = {
 2017   const uint8_t GR64_TCBits[] = {
 2027   const uint8_t GR64_NOREXBits[] = {
 2037   const uint8_t GR64_TCW64Bits[] = {
 2047   const uint8_t GR64_TC_with_sub_8bitBits[] = {
 2057   const uint8_t GR64_NOSP_and_GR64_TCBits[] = {
 2067   const uint8_t GR64_TCW64_with_sub_8bitBits[] = {
 2077   const uint8_t GR64_TC_and_GR64_TCW64Bits[] = {
 2087   const uint8_t GR64_with_sub_16bit_in_GR16_NOREXBits[] = {
 2097   const uint8_t VK64Bits[] = {
 2107   const uint8_t VR64Bits[] = {
 2117   const uint8_t GR64_NOREX_NOSPBits[] = {
 2127   const uint8_t GR64_NOREX_and_GR64_TCBits[] = {
 2137   const uint8_t GR64_NOSP_and_GR64_TCW64Bits[] = {
 2147   const uint8_t GR64_TCW64_and_GR64_TC_with_sub_8bitBits[] = {
 2157   const uint8_t VK64WMBits[] = {
 2167   const uint8_t GR64_TC_and_GR64_NOSP_and_GR64_TCW64Bits[] = {
 2177   const uint8_t GR64_TC_and_GR64_with_sub_16bit_in_GR16_NOREXBits[] = {
 2187   const uint8_t GR64_NOREX_NOSP_and_GR64_TCBits[] = {
 2197   const uint8_t GR64_NOREX_and_GR64_TCW64Bits[] = {
 2207   const uint8_t GR64_ABCDBits[] = {
 2217   const uint8_t GR64_with_sub_32bit_in_GR32_TCBits[] = {
 2227   const uint8_t GR64_with_sub_32bit_in_GR32_ABCD_and_GR32_TCBits[] = {
 2237   const uint8_t GR64_ADBits[] = {
 2247   const uint8_t GR64_and_LOW32_ADDR_ACCESS_RBPBits[] = {
 2257   const uint8_t GR64_with_sub_32bit_in_GR32_BPSPBits[] = {
 2267   const uint8_t GR64_with_sub_32bit_in_GR32_BSIBits[] = {
 2277   const uint8_t GR64_with_sub_32bit_in_GR32_CBBits[] = {
 2287   const uint8_t GR64_with_sub_32bit_in_GR32_DCBits[] = {
 2297   const uint8_t GR64_with_sub_32bit_in_GR32_DIBPBits[] = {
 2307   const uint8_t GR64_with_sub_32bit_in_GR32_SIDIBits[] = {
 2317   const uint8_t GR64_and_LOW32_ADDR_ACCESSBits[] = {
 2327   const uint8_t GR64_with_sub_32bit_in_GR32_ABCD_and_GR32_BSIBits[] = {
 2337   const uint8_t GR64_with_sub_32bit_in_GR32_AD_and_GR32_DCBits[] = {
 2347   const uint8_t GR64_with_sub_32bit_in_GR32_BPSP_and_GR32_DIBPBits[] = {
 2357   const uint8_t GR64_with_sub_32bit_in_GR32_BPSP_and_GR32_TCBits[] = {
 2367   const uint8_t GR64_with_sub_32bit_in_GR32_BSI_and_GR32_SIDIBits[] = {
 2377   const uint8_t GR64_with_sub_32bit_in_GR32_CB_and_GR32_DCBits[] = {
 2387   const uint8_t GR64_with_sub_32bit_in_GR32_DIBP_and_GR32_SIDIBits[] = {
 2397   const uint8_t RSTBits[] = {
 2407   const uint8_t RFP80Bits[] = {
 2417   const uint8_t RFP80_7Bits[] = {
 2427   const uint8_t VR128XBits[] = {
 2437   const uint8_t VR128Bits[] = {
 2447   const uint8_t BNDRBits[] = {
 2457   const uint8_t VR256XBits[] = {
 2467   const uint8_t VR256Bits[] = {
 2477   const uint8_t VR512Bits[] = {
 2487   const uint8_t VR512_0_15Bits[] = {
 8109   static const uint8_t Rows[1][10] = {
 8120     uint8_t  RotateLeft;
 8172   static const uint8_t Table[118][10] = {
 9783   static const uint8_t PressureLimitTable[] = {

  873   static const uint8_t RegAsmOffset[] = {

   61 static const uint8_t DecoderTable16[] = {
  392 static const uint8_t DecoderTable32[] = {
  802 static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
  808   const uint8_t *Ptr = DecodeTable;

  150   const uint8_t RRegsBits[] = {
  160   const uint8_t GRRegsBits[] = {
  502   static const uint8_t PressureLimitTable[] = {
  517   static const uint8_t RCSetStartTable[] = {
  527   static const uint8_t RUSetStartTable[] = {

 1028   uint8_t sizeof_char;
 1029   uint8_t sizeof_short;
 1030   uint8_t sizeof_int;
 1031   uint8_t sizeof_long;
 1032   uint8_t sizeof_long_long;
 1033   uint8_t sizeof_pointer;

  698 	auto V0 = PC.read<uint8_t>();
  707 	OS << "\t" << PC.read<uint8_t>() << " "<< "\n";
  711 bool emitConstUint8(uint8_t, const SourceInfo &);
  714 bool ByteCodeEmitter::emitConstUint8(uint8_t A0,const SourceInfo &L) {
  715 	return emitOp<uint8_t>(OP_ConstUint8, A0, L);
  719 bool EvalEmitter::emitConstUint8(uint8_t A0,const SourceInfo &L) {

18377   uint8_t result;
18400   uint8_t arg2 ;
18796   uint8_t result;
19335   uint8_t arg6 ;
29394   uint8_t *arg2 = (uint8_t *) 0 ;
29424     arg3 = (size_t) (size/sizeof(uint8_t));
29447   uint8_t *arg2 = (uint8_t *) 0 ;
29477     arg3 = (size_t) (size / sizeof(uint8_t const));
40940   uint8_t *result = 0 ;
40989   uint8_t *arg2 = (uint8_t *) 0 ;

 1897                                   uint8_t Radix);
 1906                                          unsigned SLen, uint8_t Radix);

  101 size_t LLVMDisasmInstruction(LLVMDisasmContextRef DC, uint8_t *Bytes,

  155 typedef uint8_t *(*LLVMMemoryManagerAllocateCodeSectionCallback)(
  158 typedef uint8_t *(*LLVMMemoryManagerAllocateDataSectionCallback)(

  183   void fromString(unsigned numBits, StringRef str, uint8_t radix);
  317   APInt(unsigned numBits, StringRef str, uint8_t radix);
 1598   static unsigned getBitsNeeded(StringRef str, uint8_t radix);
 2237 void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst, unsigned StoreBytes);
 2241 void LoadIntFromMemory(APInt &IntVal, uint8_t *Src, unsigned LoadBytes);

  190   uint8_t a = s[0];
  191   uint8_t b = s[len >> 1];
  192   uint8_t c = s[len - 1];

   55 inline StringRef toStringRef(ArrayRef<uint8_t> Input) {
   60 inline ArrayRef<uint8_t> arrayRefFromStringRef(StringRef Input) {
  143   const uint8_t Offset = LowerCase ? 32 : 0;
  156 inline std::string toHex(ArrayRef<uint8_t> Input, bool LowerCase = false) {
  160 inline uint8_t hexFromNibbles(char MSB, char LSB) {
  183     uint8_t Hex = hexFromNibbles(Input[0], Input[1]);

   78 enum AliasResult : uint8_t {
  102 enum class ModRefInfo : uint8_t {

  184   enum class Mode : uint8_t {

   83   uint8_t UUID[16];
  192   uint8_t StorageClass;
  193   uint8_t NumberOfAuxSymbols;
  405 enum COMDATType : uint8_t {
  425   uint8_t unused1[4];
  427   uint8_t unused2[6];
  429   uint8_t unused3[2];
  435   uint8_t unused[10];
  450   uint8_t Selection;
  455   uint8_t AuxType;
  456   uint8_t unused1;
  542   uint8_t MajorLinkerVersion;
  543   uint8_t MinorLinkerVersion;

   70 enum DwarfFormat : uint8_t { DWARF32, DWARF64 };
  126 enum TypeKind : uint8_t {
  274 enum LineNumberOps : uint8_t {
  380 inline bool isUnitType(uint8_t UnitType) {
  538   uint8_t AddrSize;
  544   uint8_t getRefAddrByteSize() const {
  551   uint8_t getDwarfOffsetByteSize() const {
  565 inline uint8_t getUnitLengthFieldByteSize(DwarfFormat Format) {
  585 Optional<uint8_t> getFixedFormByteSize(dwarf::Form Form, FormParams Params);
  616   explicit PubIndexEntryDescriptor(uint8_t Value)
  621   uint8_t toBits() const {

  301 enum NListType : uint8_t {
  584 inline bool isVirtualSection(uint8_t type) {
  781   uint8_t uuid[16];
  979   uint8_t n_type;
  980   uint8_t n_sect;
  986   uint8_t n_type;
  987   uint8_t n_sect;
  994   uint8_t n_type;
  995   uint8_t n_sect;
 1394 inline void SET_LIBRARY_ORDINAL(uint16_t &n_desc, uint8_t ordinal) {
 1398 inline uint8_t GET_COMM_ALIGN(uint16_t n_desc) {
 1402 inline void SET_COMM_ALIGN(uint16_t &n_desc, uint8_t align) {
 1601   uint8_t fpu_ftw;
 1602   uint8_t fpu_rsrv1;

  154     uint8_t ProcessorFeatures[16];
  166   uint8_t NumberOfProcessors;
  167   uint8_t ProductType;

   48 enum class Type : uint8_t {

   53   uint8_t Prefix;
   59   uint8_t Kind;
   64   uint8_t Flags;
   70   uint8_t ElemType;
   75   uint8_t Opcode;
   86   uint8_t Type;
  112   uint8_t Kind;
  123   uint8_t Type;
  130   ArrayRef<uint8_t> Body;
  143   ArrayRef<uint8_t> Content;
  165   uint8_t Type;    // The type of the relocation.
  178   uint8_t Kind;
  283 enum : uint8_t {

   28 enum StorageMappingClass : uint8_t {
   76 enum StorageClass : uint8_t {
  152 enum RelocationType : uint8_t {
  236 enum CFileStringType : uint8_t {
  243 enum CFileLangId : uint8_t {
  248 enum CFileCpuId : uint8_t {

   59     ArrayRef<uint8_t> Buffer;
   71     BitcodeModule(ArrayRef<uint8_t> Buffer, StringRef ModuleIdentifier,

   81   ArrayRef<uint8_t> BitcodeBytes;
  103   explicit SimpleBitstreamCursor(ArrayRef<uint8_t> BitcodeBytes)
  127   ArrayRef<uint8_t> getBitcodeBytes() const { return BitcodeBytes; }
  151   const uint8_t *getPointerToByte(uint64_t ByteNo, uint64_t NumBytes) {
  158   const uint8_t *getPointerToBit(uint64_t BitNo, uint64_t NumBytes) {
  170     const uint8_t *NextCharPtr = BitcodeBytes.data() + NextChar;
  363   explicit BitstreamCursor(ArrayRef<uint8_t> BitcodeBytes)

  247   enum class SledKind : uint8_t {
  266     uint8_t Version;
  279                   uint8_t Version = 0);

  858   const uint8_t AddrSize; /// The size in bytes of an address for this unit.
  863   DIEUnit(uint16_t Version, uint8_t AddrSize, dwarf::Tag UnitTag);
  896   BasicDIEUnit(uint16_t Version, uint8_t AddrSize, dwarf::Tag UnitTag)

   83   using FaultMapVersionType = uint8_t;
   84   using Reserved0Type = uint8_t;
   97   const uint8_t *P;
   98   const uint8_t *E;
  100   template <typename T> static T read(const uint8_t *P, const uint8_t *E) {
  100   template <typename T> static T read(const uint8_t *P, const uint8_t *E) {
  117     const uint8_t *P;
  118     const uint8_t *E;
  124     explicit FunctionFaultInfoAccessor(const uint8_t *P, const uint8_t *E)
  124     explicit FunctionFaultInfoAccessor(const uint8_t *P, const uint8_t *E)
  154     const uint8_t *P = nullptr;
  155     const uint8_t *E = nullptr;
  160     explicit FunctionInfoAccessor(const uint8_t *P, const uint8_t *E)
  160     explicit FunctionInfoAccessor(const uint8_t *P, const uint8_t *E)
  173       const uint8_t *Begin = P + FunctionFaultInfosOffset +
  182       const uint8_t *Begin = P + MySize;
  188   explicit FaultMapParser(const uint8_t *Begin, const uint8_t *End)
  188   explicit FaultMapParser(const uint8_t *Begin, const uint8_t *End)
  202     const uint8_t *Begin = P + FunctionInfosOffset;

   44 enum LegalizeAction : std::uint8_t {

  160     uint8_t StackID;
  182     uint8_t SSPLayout;
  186                 bool IsAliased, uint8_t StackID = 0)
  700   uint8_t getStackID(int ObjectIdx) const {
  705   void setStackID(int ObjectIdx, uint8_t ID) {
  738                         const AllocaInst *Alloca = nullptr, uint8_t ID = 0);
  743                                uint8_t ID = 0) {

  125   uint8_t AsmPrinterFlags = 0;          // Various bits of information used by
  286   uint8_t getAsmPrinterFlags() const { return AsmPrinterFlags; }
  297   void setAsmPrinterFlag(uint8_t Flag) {

   45   uint8_t StackID;
   50                               uint8_t ID = 0)
   56                               uint8_t ID = 0)
   68     uint8_t ID = 0)
  111                                      uint8_t ID = 0);

  789   enum CandReason : uint8_t {

   35     uint8_t MinCost = 0;

  113   enum LegalizeAction : uint8_t {
  123   enum LegalizeTypeAction : uint8_t {
  726   virtual uint8_t getRepRegClassCostFor(MVT VT) const {
 2026   virtual std::pair<const TargetRegisterClass *, uint8_t>
 2759   uint8_t RepRegClassCostForVT[MVT::LAST_VALUETYPE];
 2791   uint8_t IndexedModeActions[MVT::LAST_VALUETYPE][ISD::LAST_INDEXED_MODE];

   57   const uint8_t AllocationPriority;

   35   SmallVector<ArrayRef<uint8_t>, 2> SeenRecords;
   56   ArrayRef<ArrayRef<uint8_t>> records() const;
   57   TypeIndex insertRecordBytes(ArrayRef<uint8_t> &Record);
   61     ArrayRef<uint8_t> Data = SimpleSerializer.serialize(Record);

   34   CVRecord(ArrayRef<uint8_t> Data) : RecordData(Data) {}
   50   ArrayRef<uint8_t> data() const { return RecordData; }
   57   ArrayRef<uint8_t> content() const {
   61   ArrayRef<uint8_t> RecordData;
   72 Error forEachCodeViewRecord(ArrayRef<uint8_t> StreamBuffer, Func F) {
   84     ArrayRef<uint8_t> Data = StreamBuffer.take_front(RealLen);
  108   ArrayRef<uint8_t> RawData;

   38 Error visitMemberRecord(TypeLeafKind Kind, ArrayRef<uint8_t> Record,
   41 Error visitMemberRecordStream(ArrayRef<uint8_t> FieldList,

  143 enum SourceLanguage : uint8_t {
  173 enum class CallingConvention : uint8_t {
  244 enum class FunctionOptions : uint8_t {
  252 enum class HfaKind : uint8_t {
  260 enum class MemberAccess : uint8_t {
  268 enum class MethodKind : uint8_t {
  331 enum class PointerKind : uint8_t {
  348 enum class PointerMode : uint8_t {
  383 enum class VFTableSlotKind : uint8_t {
  393 enum class WindowsRTClassKind : uint8_t {
  428 enum class ProcSymFlags : uint8_t {
  506 enum class FrameCookieKind : uint8_t {
  536 enum class EncodedFramePtrReg : uint8_t {
  548 enum class ThunkOrdinal : uint8_t {
  561 enum class FileChecksumKind : uint8_t { None, MD5, SHA1, SHA256 };

  199   Error mapByteVectorTail(ArrayRef<uint8_t> &Bytes, const Twine &Comment = "");
  200   Error mapByteVectorTail(std::vector<uint8_t> &Bytes,

   40   ArrayRef<uint8_t> InjectedSegmentBytes;

   34   ArrayRef<uint8_t> Checksum; // The bytes of the checksum.
   84                    ArrayRef<uint8_t> Bytes);

   25 ArrayRef<EnumEntry<uint8_t>> getProcSymFlagNames();
   27 ArrayRef<EnumEntry<uint8_t>> getFrameCookieKindNames();
   36 ArrayRef<EnumEntry<uint8_t>> getThunkOrdinalNames();
   41 ArrayRef<EnumEntry<uint8_t>> getMemberAccessNames();
   44 ArrayRef<EnumEntry<uint8_t>> getPtrKindNames();
   45 ArrayRef<EnumEntry<uint8_t>> getPtrModeNames();
   48 ArrayRef<EnumEntry<uint8_t>> getCallingConventions();
   49 ArrayRef<EnumEntry<uint8_t>> getFunctionOptionEnum();

   27 class GuidAdapter final : public FormatAdapter<ArrayRef<uint8_t>> {
   28   ArrayRef<uint8_t> Guid;
   31   explicit GuidAdapter(ArrayRef<uint8_t> Guid);
   43 inline detail::GuidAdapter fmt_guid(ArrayRef<uint8_t> Item) {

   22   uint8_t Guid[16];

   44   SmallVector<ArrayRef<uint8_t>, 2> SeenRecords;
   68   ArrayRef<ArrayRef<uint8_t>> records() const;
   78       uint8_t *Stable = RecordStorage.Allocate<uint8_t>(RecordSize);
   78       uint8_t *Stable = RecordStorage.Allocate<uint8_t>(RecordSize);
   79       MutableArrayRef<uint8_t> Data(Stable, RecordSize);
   80       ArrayRef<uint8_t> StableRecord = Create(Data);
  103   TypeIndex insertRecordBytes(ArrayRef<uint8_t> Data);
  107     ArrayRef<uint8_t> Data = SimpleSerializer.serialize(Record);

   62   LazyRandomTypeCollection(ArrayRef<uint8_t> Data, uint32_t RecordCountHint);
   67   void reset(ArrayRef<uint8_t> Data, uint32_t RecordCountHint);

   44   SmallVector<ArrayRef<uint8_t>, 2> SeenRecords;
   65   ArrayRef<ArrayRef<uint8_t>> records() const;
   67   TypeIndex insertRecordAs(hash_code Hash, ArrayRef<uint8_t> &Record);
   68   TypeIndex insertRecordBytes(ArrayRef<uint8_t> &Record);
   72     ArrayRef<uint8_t> Data = SimpleSerializer.serialize(Record);

   43 StringRef getBytesAsCharacters(ArrayRef<uint8_t> LeafData);
   44 StringRef getBytesAsCString(ArrayRef<uint8_t> LeafData);

   34   std::vector<uint8_t> ScratchBuffer;
   43   template <typename T> ArrayRef<uint8_t> serialize(T &Record);
   46   ArrayRef<uint8_t> serialize(const FieldListRecord &Record) = delete;

   26     MappingInfo(ArrayRef<uint8_t> RecordData, CodeViewContainer Container)

   28                                           ArrayRef<uint8_t> Block) = 0;

   84   ArrayRef<uint8_t> VariantData;
  114   uint8_t Alignment = 0;
  161   ArrayRef<uint8_t> Bytes;
  173   BinaryAnnotationIterator(ArrayRef<uint8_t> Annotations) : Data(Annotations) {}
  203   static uint32_t GetCompressedAnnotation(ArrayRef<uint8_t> &Annotations) {
  207     uint8_t FirstByte = Annotations.front();
  216     uint8_t SecondByte = Annotations.front();
  225     uint8_t ThirdByte = Annotations.front();
  231     uint8_t FourthByte = Annotations.front();
  247   static int32_t DecodeSignedOperand(ArrayRef<uint8_t> &Annotations) {
  328   ArrayRef<uint8_t> Data;
  329   ArrayRef<uint8_t> Next;
  348   std::vector<uint8_t> AnnotationData;
  714   uint8_t getLanguage() const { return static_cast<uint32_t>(Flags) & 0xFF; }
  851   uint8_t Flags = 0;

   33   std::array<uint8_t, MaxRecordLength> RecordBuffer;

   30     explicit MappingInfo(ArrayRef<uint8_t> RecordData)
   55   static Expected<T> deserializeAs(ArrayRef<uint8_t> Data) {

   34   ArrayRef<uint8_t> RecordData;
   37   static LocallyHashedType hashType(ArrayRef<uint8_t> RecordData);
   81   GloballyHashedType(ArrayRef<uint8_t> H) {
   85   std::array<uint8_t, 8> Hash;
   93   static GloballyHashedType hashType(ArrayRef<uint8_t> RecordData,
  225     for (uint8_t B : V.Hash) {

   26 void discoverTypeIndices(ArrayRef<uint8_t> RecordData,
   32 void discoverTypeIndices(ArrayRef<uint8_t> RecordData,
   39 bool discoverTypeIndicesInSymbol(ArrayRef<uint8_t> RecordData,
   41 bool discoverTypeIndicesInSymbol(ArrayRef<uint8_t> RecordData,

   40   ArrayRef<uint8_t> Data;
  294                 PointerOptions PO, uint8_t Size)
  299                 PointerOptions PO, uint8_t Size, const MemberPointerInfo &MPI)
  319   uint8_t getSize() const {
  358                 uint8_t Size) {
  364                             uint8_t Size) {
  394   explicit FieldListRecord(ArrayRef<uint8_t> Data)
  397   ArrayRef<uint8_t> Data;
  544   BitFieldRecord(TypeIndex Type, uint8_t BitSize, uint8_t BitOffset)
  544   BitFieldRecord(TypeIndex Type, uint8_t BitSize, uint8_t BitOffset)
  549   uint8_t getBitOffset() const { return BitOffset; }
  550   uint8_t getBitSize() const { return BitSize; }
  553   uint8_t BitSize;
  554   uint8_t BitOffset;

   22   explicit TypeTableCollection(ArrayRef<ArrayRef<uint8_t>> Records);
   37   ArrayRef<ArrayRef<uint8_t>> Records;

  176   uint8_t AddrSize = 4; // Address byte size to assume when extracting.

   34     AttributeSpec(dwarf::Attribute A, dwarf::Form F, Optional<uint8_t> ByteSize)
   61       uint8_t ByteSize;
   89   uint8_t getCodeByteSize() const { return CodeByteSize; }
  154     uint8_t NumAddrs = 0;
  156     uint8_t NumRefAddrs = 0;
  158     uint8_t NumDwarfOffsets = 0;
  173   uint8_t CodeByteSize;

  356          uint8_t AddrSize, bool isLittleEndian = sys::IsLittleEndianHost);
  365   uint8_t getCUAddrSize();

   28                      bool IsLittleEndian, uint8_t AddressSize)
   33   DWARFDataExtractor(StringRef Data, bool IsLittleEndian, uint8_t AddressSize)
   56   Optional<uint64_t> getEncodedPointer(uint64_t *Offset, uint8_t Encoding,

   40     uint8_t AddrSize;
   43     uint8_t SegSize = 0;
   58                 uint16_t Version, uint8_t AddrSize,
   62   uint8_t getAddrSize() const { return HeaderData.AddrSize; }
   70   uint8_t getHeaderSize() const {

   34     uint8_t AddrSize;
   37     uint8_t SegSize;

   42     Instruction(uint8_t Opcode) : Opcode(Opcode) {}
   44     uint8_t Opcode;
   84   void addInstruction(uint8_t Opcode) {
   89   void addInstruction(uint8_t Opcode, uint64_t Operand1) {
   95   void addInstruction(uint8_t Opcode, uint64_t Operand1, uint64_t Operand2) {
  169   CIE(uint64_t Offset, uint64_t Length, uint8_t Version,
  193   uint8_t getVersion() const { return Version; }
  207   const uint8_t Version;
  209   const uint8_t AddressSize;
  210   const uint8_t SegmentDescriptorSize;

   77     uint8_t SegSelectorSize;
   81     uint8_t MinInstLength;
   84     uint8_t MaxOpsPerInst;
   86     uint8_t DefaultIsStmt;
   90     uint8_t LineRange;
   92     uint8_t OpcodeBase;
   95     std::vector<uint8_t> StandardOpcodeLengths;
  101     uint8_t getAddressSize() const { return FormParams.AddrSize; }
  182     uint8_t Isa;
  185     uint8_t IsStmt : 1,

   33     SmallVector<uint8_t, 4> Loc;
   80     uint8_t Kind;
   84     SmallVector<uint8_t, 4> Loc;

   52     bool isBaseAddressSelectionEntry(uint8_t AddressSize) const {
   63   uint8_t AddressSize;

   38   void dump(raw_ostream &OS, uint8_t AddrSize, uint8_t MaxEncodingStringLength,
   38   void dump(raw_ostream &OS, uint8_t AddrSize, uint8_t MaxEncodingStringLength,

   35     enum Encoding : uint8_t {
   54     enum DwarfVersion : uint8_t {
   77     uint8_t Opcode; ///< The Op Opcode, DW_OP_<something>.
   86     uint8_t getCode() { return Opcode; }
   90     bool extract(DataExtractor Data, uint16_t Version, uint8_t AddressSize,
  130   DWARFExpression(DataExtractor Data, uint16_t Version, uint8_t AddressSize)
  146   uint8_t AddressSize;

   53     const uint8_t *data = nullptr;
   71                                              ArrayRef<uint8_t> D);
  118   Optional<ArrayRef<uint8_t>> getAsBlock() const;
  311 inline Optional<ArrayRef<uint8_t>> toBlock(const Optional<DWARFFormValue> &V) {

   31   uint8_t EntryKind;
   66     uint8_t AddrSize;
   69     uint8_t SegSize;
   99   uint8_t getAddrSize() const { return HeaderData.AddrSize; }
  108   static uint8_t getHeaderSize(dwarf::DwarfFormat Format) {
  169   uint8_t getAddrSize() const { return Header.getAddrSize(); }
  184   uint8_t getHeaderSize() const {

   34   virtual uint8_t getAddressSize() const { llvm_unreachable("unimplemented"); }

   65   uint8_t UnitType = 0;
   68   uint8_t Size = 0;
   80   uint8_t getAddressByteSize() const { return FormParams.AddrSize; }
   81   uint8_t getRefAddrByteSize() const { return FormParams.getRefAddrByteSize(); }
   82   uint8_t getDwarfOffsetByteSize() const {
   95   uint8_t getUnitType() const { return UnitType; }
   99   uint8_t getSize() const { return Size; }
  100   uint8_t getUnitLengthFieldByteSize() const {
  177                                    uint8_t Version, dwarf::DwarfFormat Format)
  181   uint8_t getVersion() const { return FormParams.Version; }
  183   uint8_t getDwarfOffsetByteSize() const {
  284   uint8_t getAddressByteSize() const { return Header.getAddressByteSize(); }
  285   uint8_t getRefAddrByteSize() const { return Header.getRefAddrByteSize(); }
  286   uint8_t getDwarfOffsetByteSize() const {
  290   uint8_t getUnitType() const { return Header.getUnitType(); }
  335   uint8_t getDwarfStringOffsetsByteSize() const {
  347   static bool isMatchingUnitTypeAndTag(uint8_t UnitType, dwarf::Tag Tag) {
  369   static uint32_t getDWARF5HeaderSize(uint8_t UnitType) {

  141                         uint64_t *Offset, unsigned UnitIndex, uint8_t &UnitType,

   40   void writeU8(uint8_t Value);
   79   void writeData(llvm::ArrayRef<uint8_t> Data);

  140   std::vector<uint8_t> UUID;
  206   void setUUID(llvm::ArrayRef<uint8_t> UUIDBytes) {

   56   ArrayRef<uint8_t> AddrOffsets;
   66     std::vector<uint8_t> AddrOffsets;

   56   uint8_t AddrOffSize;
   58   uint8_t UUIDSize;
   86   uint8_t UUID[GSYM_MAX_UUID_SIZE];

   32   virtual Expected<ArrayRef<uint8_t>> getBlockData(uint32_t BlockIndex,
   35                              ArrayRef<uint8_t> Data) const = 0;

   64                   ArrayRef<uint8_t> &Buffer) override;
   66                                    ArrayRef<uint8_t> &Buffer) override;
   84   void fixCacheAfterWrite(uint32_t Offset, ArrayRef<uint8_t> Data) const;
   86   Error readBytes(uint32_t Offset, MutableArrayRef<uint8_t> Buffer);
   88                            ArrayRef<uint8_t> &Buffer);
   94   using CacheEntry = MutableArrayRef<uint8_t>;
  131                   ArrayRef<uint8_t> &Buffer) override;
  133                                    ArrayRef<uint8_t> &Buffer) override;
  136   Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Buffer) override;

   25   using RecordType = SmallVector<uint8_t, 32>;

   89   virtual void getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes) const = 0;

   53   void addSymbolsInBulk(ArrayRef<uint8_t> BulkSymbols);
   94   std::vector<ArrayRef<uint8_t>> Symbols;

   54   void setBuildNumber(uint8_t Major, uint8_t Minor);
   54   void setBuildNumber(uint8_t Major, uint8_t Minor);
   63   Error addDbgStream(pdb::DbgHeaderType Type, ArrayRef<uint8_t> Data);

   29   static ArrayRef<uint8_t> bytes(const codeview::CVSymbol &Item) {

   21 uint32_t hashBufferV8(ArrayRef<uint8_t> Data);

   64   void getDataBytes(SmallVector<uint8_t, 32> &Bytes) const override;

   70   Expected<ArrayRef<uint8_t>> getBlockData(uint32_t BlockIndex,
   73                      ArrayRef<uint8_t> Data) const override;

  326   uint8_t Padding[44];          // Pad to 64 bytes.
  339   uint8_t Compression;           // PDB_SourceCompression enumeration.
  340   uint8_t IsVirtual;             // Is this a virtual file (injected)?

   61   uint8_t State = 0;

   30   static ArrayRef<uint8_t> bytes(const codeview::CVType &Item) {
   56   void addTypeRecord(ArrayRef<uint8_t> Type, Optional<uint32_t> Hash);
   77   std::vector<ArrayRef<uint8_t>> TypeRecords;

   29   void getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes);

  428   explicit Variant(uint8_t V) : Type(PDB_VariantType::UInt8) {
  459     uint8_t UInt8;

   30     uint8_t *Buf = nullptr;
   38     NewHead->Buf = new uint8_t[Capacity];
   61     uint8_t *P = Head->Buf + Head->Used;
   79     uint8_t *PP = (uint8_t *)AlignedP;
   98     uint8_t *PP = (uint8_t *)AlignedP;
  129 enum NameBackrefBehavior : uint8_t {
  252   uint8_t demangleCharLiteral(StringView &MangledName);

   35 enum Qualifiers : uint8_t {
   46 enum class StorageClass : uint8_t {
   59 enum class CallingConv : uint8_t {
   72 enum class ReferenceKind : uint8_t { None, LValueRef, RValueRef };
  115 enum class IntrinsicFunctionKind : uint8_t {

   59   using Kind = uint8_t;
  250 enum class Linkage : uint8_t {
  262 enum class Scope : uint8_t { Default, Hidden, Local };

   58   using UnderlyingType = uint8_t;
   59   using TargetFlagsType = uint8_t;

   38 enum class SymbolState : uint8_t;
  429 enum class SymbolState : uint8_t {
  701     uint8_t State : 6;
  702     uint8_t MaterializerAttached : 1;
  703     uint8_t PendingRemoval : 1;

  158     uint8_t *TrampolineMem = static_cast<uint8_t *>(TrampolineBlock.base());

   45   static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,
   51   static void writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,
  128   static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,
  134   static void writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,
  160   static void writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,
  185   static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,
  201   static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,
  221   static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,
  227   static void writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,
  255   static void writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,unsigned NumTrampolines);
  259   static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,void *CallbackMgr, bool isBigEndian);
  272   static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,void *CallbackMgr)
  278   static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,void *CallbackMgr)
  296   static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,void *CallbackMgr);
  301   static void writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,unsigned NumTrampolines);

   74     uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
   78       uint8_t *Alloc = reinterpret_cast<uint8_t *>(
   86     uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
   91         uint8_t *Alloc = reinterpret_cast<uint8_t *>(
  100       uint8_t *Alloc = reinterpret_cast<uint8_t *>(
  152     void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr,
  642   Expected<std::vector<uint8_t>> readMem(char *Dst, JITTargetAddress Src,

  239       : public rpc::Function<ReadMem, std::vector<uint8_t>(JITTargetAddress Src,

   54       std::function<void(uint8_t *Addr, uint32_t Size)>;
  227     uint8_t *Addr = reinterpret_cast<uint8_t *>(static_cast<uintptr_t>(TAddr));
  311     uint8_t *TrampolineMem = static_cast<uint8_t *>(TrampolineBlock.base());
  352   Expected<std::vector<uint8_t>> handleReadMem(JITTargetAddress RSrc,
  354     uint8_t *Src = reinterpret_cast<uint8_t *>(static_cast<uintptr_t>(RSrc));
  359     std::vector<uint8_t> Buffer;
  361     for (uint8_t *P = Src; Size != 0; --Size)
  368     uint8_t *Addr = reinterpret_cast<uint8_t *>(static_cast<uintptr_t>(TAddr));

  117     uint8_t Tmp = V ? 1 : 0;
  125     uint8_t Tmp = 0;

   69   static void registerEHFramesInProcess(uint8_t *Addr, size_t Size);
   72   static void deregisterEHFramesInProcess(uint8_t *Addr, size_t Size);
   74   void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) override;
  142     uint8_t *Addr;

  104     virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
  111     virtual uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
  139     virtual void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr,

  118   uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
  127   uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
  178   uint8_t *allocateSection(AllocationPurpose Purpose, uintptr_t Size,

   43 using FuzzerTestFun = int (*)(const uint8_t *Data, size_t Size);
   58 std::unique_ptr<Module> parseModule(const uint8_t *Data, size_t Size,
   68 size_t writeModule(const Module &M, uint8_t *Dest, size_t MaxSize);
   73 std::unique_ptr<Module> parseAndVerify(const uint8_t *Data, size_t Size,

  128                           uint8_t radix);
  773   static Constant *get(LLVMContext &Context, ArrayRef<uint8_t> Elts);

 1067   uint8_t CC;
 1070                    uint8_t CC, ArrayRef<Metadata *> Ops)
 1077                                    uint8_t CC, DITypeRefArray TypeArray,
 1083                                    uint8_t CC, Metadata *TypeArray,
 1101   uint8_t getCC() const { return CC; }
 2485   enum PrependOps : uint8_t {
 2495   static DIExpression *prepend(const DIExpression *Expr, uint8_t Flags,

  348   ConstantInt *getInt8(uint8_t C) {

 2038     uint8_t *BytesBegin = getDescriptor().begin();
 2055     uint8_t *BytesEnd = getDescriptor().end();

  214     enum RoundingMode : uint8_t {
  225     enum ExceptionBehavior : uint8_t {

   43 typedef uint8_t ID;

   54   enum class HotnessType : uint8_t {
  821   uint8_t BitMask = 0;

  194   ArrayRef<const uint8_t> getDescriptor() const;
  197   MutableArrayRef<uint8_t> getDescriptor();

  144                ArrayRef<uint8_t> ChecksumBytes, uint8_t ChecksumKind);
  144                ArrayRef<uint8_t> ChecksumBytes, uint8_t ChecksumKind);
  236     uint8_t ChecksumKind;
  238     ArrayRef<uint8_t> Checksum;

   79                                       ArrayRef<uint8_t> Bytes, uint64_t Address,
   96                                      ArrayRef<uint8_t> Bytes, uint64_t Address,

   75   uint8_t Flags;
   76   uint8_t Isa;
  205   uint8_t DWARF2LineOpcodeBase = 13;
  210   uint8_t DWARF2LineRange = 14;

   55   const uint8_t OSABI;
   56   const uint8_t ABIVersion;
   62   MCELFObjectTargetWriter(bool Is64Bit_, uint8_t OSABI_, uint16_t EMachine_,
   63                           bool HasRelocationAddend_, uint8_t ABIVersion_ = 0);
   73   static uint8_t getOSABI(Triple::OSType OSType) {
  100   uint8_t getOSABI() const { return OSABI; }
  101   uint8_t getABIVersion() const { return ABIVersion; }
  119   uint8_t getRType(uint32_t Type) const {
  122   uint8_t getRType2(uint32_t Type) const {
  125   uint8_t getRType3(uint32_t Type) const {
  128   uint8_t getRSsym(uint32_t Type) const {

   34   enum FragmentType : uint8_t {
  131   uint8_t BundlePadding = 0;
  166   uint8_t getBundlePadding() const { return BundlePadding; }
  170   void setBundlePadding(uint8_t N) { BundlePadding = N; }
  432   uint8_t ValueSize;
  440   MCFillFragment(uint64_t Value, uint8_t VSize, const MCExpr &NumValues,
  446   uint8_t getValueSize() const { return ValueSize; }
  476   uint8_t getValue() const { return Value; }

   26 void dumpBytes(ArrayRef<uint8_t> Bytes, raw_ostream &OS);

  163   findPltEntries(uint64_t PltSectionVA, ArrayRef<uint8_t> PltContents,

   79   uint8_t Flags;
   82   uint8_t OperandType;

   86     uint8_t SectionIndex;

   35   const uint8_t *const RegSet;

  148                              const SmallVectorImpl<uint8_t> &Opcodes);
  714   void emitFill(uint64_t NumBytes, uint8_t FillValue);
  843                                    ArrayRef<uint8_t> Checksum,

   56   enum Contents : uint8_t {

   66   void write(uint8_t *Buf) const;

   93   uint8_t              UUID[16];
  106   uint8_t MajorLinkerVersion;
  107   uint8_t MinorLinkerVersion;
  142   uint8_t MajorLinkerVersion;
  143   uint8_t MinorLinkerVersion;
  261   uint8_t StorageClass;
  262   uint8_t NumberOfAuxSymbols;
  338   uint8_t getStorageClass() const {
  343   uint8_t getNumberOfAuxSymbols() const {
  348   uint8_t getBaseType() const { return getType() & 0x0F; }
  350   uint8_t getComplexType() const {
  517   uint8_t              Selection;
  518   uint8_t              Unused;
  532   uint8_t              AuxType;
  533   uint8_t              Reserved;
  907   Expected<ArrayRef<uint8_t>>
  940   uint8_t getBytesInAddress() const override;
 1027   ArrayRef<uint8_t> getSymbolAuxData(COFFSymbolRef Symbol) const;
 1044                            ArrayRef<uint8_t> &Res) const;
 1054                                        ArrayRef<uint8_t> &Contents) const;
 1197   std::error_code getType(uint8_t &Type) const;

   32   uint8_t Signature[16];

  109   const uint8_t *base() const { return Buf.bytes_begin(); }
  168   Expected<const uint8_t *> toMappedAddr(uint64_t VAddr) const;
  301   Expected<ArrayRef<uint8_t>> getSectionContents(const Elf_Shdr *Sec) const;
  421 Expected<ArrayRef<uint8_t>>
  423   return getSectionContentsAsArray<uint8_t>(Sec);
  444     uint8_t Type1 = (Type >> 0) & 0xFF;
  445     uint8_t Type2 = (Type >> 8) & 0xFF;
  446     uint8_t Type3 = (Type >> 16) & 0xFF;

   58   virtual uint8_t getSymbolBinding(DataRefImpl Symb) const = 0;
   59   virtual uint8_t getSymbolOther(DataRefImpl Symb) const = 0;
   60   virtual uint8_t getSymbolELFType(DataRefImpl Symb) const = 0;
  150   uint8_t getBinding() const {
  154   uint8_t getOther() const {
  158   uint8_t getELFType() const {
  163     uint8_t Type = getELFType();
  265   uint8_t getSymbolBinding(DataRefImpl Symb) const override;
  266   uint8_t getSymbolOther(DataRefImpl Symb) const override;
  267   uint8_t getSymbolELFType(DataRefImpl Symb) const override;
  278   Expected<ArrayRef<uint8_t>>
  424   uint8_t getBytesInAddress() const override;
  571 uint8_t ELFObjectFile<ELFT>::getSymbolBinding(DataRefImpl Symb) const {
  576 uint8_t ELFObjectFile<ELFT>::getSymbolOther(DataRefImpl Symb) const {
  581 uint8_t ELFObjectFile<ELFT>::getSymbolELFType(DataRefImpl Symb) const {
  723 Expected<ArrayRef<uint8_t>>
 1049 uint8_t ELFObjectFile<ELFT>::getBytesInAddress() const {

  611   ArrayRef<uint8_t> getDesc() const {
  614     return ArrayRef<uint8_t>(
  646   void advanceNhdr(const uint8_t *NhdrPos, size_t NoteSize) {
  666   Elf_Note_Iterator_Impl(const uint8_t *Start, size_t Size, Error &Err)
  676     const uint8_t *NhdrPos = reinterpret_cast<const uint8_t *>(Nhdr);
  728   uint8_t kind;     // Determines interpretation of variable part of descriptor
  729   uint8_t size;     // Byte size of descriptor, including this header
  748   uint8_t isa_level; // ISA level: 1-5, 32, and 64
  749   uint8_t isa_rev;   // ISA revision (0 for MIPS I - MIPS V)
  750   uint8_t gpr_size;  // General purpose registers size
  751   uint8_t cpr1_size; // Co-processor 1 registers size
  752   uint8_t cpr2_size; // Co-processor 2 registers size
  753   uint8_t fp_abi;    // Floating-point ABI flag

   74   ExportEntry(Error *Err, const MachOObjectFile *O, ArrayRef<uint8_t> Trie);
   92   uint64_t readULEB128(const uint8_t *&p, const char **error);
   98     NodeState(const uint8_t *Ptr);
  100     const uint8_t *Start;
  101     const uint8_t *Current;
  116   ArrayRef<uint8_t> Trie;
  137                                  uint8_t PointerSize, uint32_t Count=1,
  170                    ArrayRef<uint8_t> opcodes, bool is64Bit);
  192   ArrayRef<uint8_t> Opcodes;
  193   const uint8_t *Ptr;
  198   uint8_t  RebaseType = 0;
  199   uint8_t  PointerSize;
  216                  ArrayRef<uint8_t> Opcodes, bool is64Bit, MachOBindEntry::Kind);
  244   ArrayRef<uint8_t> Opcodes;
  245   const uint8_t *Ptr;
  255   uint8_t  BindType = 0;
  256   uint8_t  PointerSize;
  300   ArrayRef<uint8_t> getSectionContents(uint32_t Offset, uint64_t Size) const;
  301   Expected<ArrayRef<uint8_t>>
  341   uint8_t getRelocationLength(DataRefImpl Rel) const;
  362   uint8_t getBytesInAddress() const override;
  384                                                  ArrayRef<uint8_t> Trie,
  394                                                      ArrayRef<uint8_t> Opcodes,
  409                                                  ArrayRef<uint8_t> Opcodes,
  420                                          uint8_t PointerSize, uint32_t Count=1,
  434                                             uint8_t PointerSize,
  556   ArrayRef<uint8_t> getDyldInfoRebaseOpcodes() const;
  557   ArrayRef<uint8_t> getDyldInfoBindOpcodes() const;
  558   ArrayRef<uint8_t> getDyldInfoWeakBindOpcodes() const;
  559   ArrayRef<uint8_t> getDyldInfoLazyBindOpcodes() const;
  560   ArrayRef<uint8_t> getDyldInfoExportsTrie() const;
  561   ArrayRef<uint8_t> getUuid() const;

   39   ArrayRef<uint8_t> getRawStream(const minidump::Directory &Stream) const {
   45   Optional<ArrayRef<uint8_t>> getRawStream(minidump::StreamType Type) const;
   49   Expected<ArrayRef<uint8_t>>
  110     MemoryInfoIterator(ArrayRef<uint8_t> Storage, size_t Stride)
  130     ArrayRef<uint8_t> Storage;
  154   static Expected<ArrayRef<uint8_t>> getDataSlice(ArrayRef<uint8_t> Data,
  154   static Expected<ArrayRef<uint8_t>> getDataSlice(ArrayRef<uint8_t> Data,
  161   static Expected<ArrayRef<T>> getDataSliceAs(ArrayRef<uint8_t> Data,
  170   ArrayRef<uint8_t> getData() const {
  191   if (Optional<ArrayRef<uint8_t>> Stream = getRawStream(Type)) {
  200 Expected<ArrayRef<T>> MinidumpFile::getDataSliceAs(ArrayRef<uint8_t> Data,
  206   Expected<ArrayRef<uint8_t>> Slice =

  227   const uint8_t *base() const {
  260   virtual Expected<ArrayRef<uint8_t>>
  316   virtual uint8_t getBytesInAddress() const = 0;
  449   Expected<ArrayRef<uint8_t>> Res =

   72     FunctionAccessor(const uint8_t *P) : P(P) {}
   80     const uint8_t *P;
   92     ConstantAccessor(const uint8_t *P) : P(P) {}
  100     const uint8_t *P;
  103   enum class LocationKind : uint8_t {
  151     LocationAccessor(const uint8_t *P) : P(P) {}
  163     const uint8_t *P;
  179       return read<uint8_t>(P + SizeOffset);
  183     LiveOutAccessor(const uint8_t *P) : P(P) {}
  191       DwarfRegNumOffset + sizeof(uint16_t) + sizeof(uint8_t);
  194     const uint8_t *P;
  271     RecordAccessor(const uint8_t *P) : P(P) {}
  299     const uint8_t *P;
  304   StackMapParser(ArrayRef<uint8_t> StackMapSection)
  419   static T read(const uint8_t *P) {
  440   ArrayRef<uint8_t> StackMapSection;

  109   ArrayRef<uint8_t> Content; // Section content
  178   Expected<ArrayRef<uint8_t>>
  200   uint8_t getBytesInAddress() const override;
  208     const uint8_t *Start;
  209     const uint8_t *Ptr;
  210     const uint8_t *End;

  113   ArrayRef<uint8_t> getData() const { return Data; }
  133   ArrayRef<uint8_t> Data;
  163   const ArrayRef<std::vector<uint8_t>> getData() const { return Data; }
  204                   std::vector<std::vector<uint8_t>> &Data,
  212                          std::vector<std::vector<uint8_t>> &Data,
  254   std::vector<std::vector<uint8_t>> Data;

   89     uint8_t LanguageId;
   90     uint8_t CpuTypeId;
  107   uint8_t NumberOfAuxEntries;
  124   uint8_t SymbolAlignmentAndType;
  141   uint8_t ReservedZeros[2];
  142   uint8_t AuxType; // 64-bit XCOFF file only.
  149   uint8_t Pad[10];
  157   static constexpr uint8_t XR_SIGN_INDICATOR_MASK = 0x80;
  161   static constexpr uint8_t XR_FIXUP_INDICATOR_MASK = 0x40;
  165   static constexpr uint8_t XR_BIASED_LENGTH_MASK = 0x3f;
  172   uint8_t Info;
  181   uint8_t getRelocatedLength() const;
  253   Expected<ArrayRef<uint8_t>>
  274   uint8_t getBytesInAddress() const override;
  346   uint8_t getNumberOfAuxEntries() const;

   81   std::vector<uint8_t> Bytes;
  126 fromDebugS(ArrayRef<uint8_t> Data, const codeview::StringsAndChecksumsRef &SC);

   36   explicit GlobalHash(ArrayRef<uint8_t> S) : Hash(S) {
   49 DebugHSection fromDebugH(ArrayRef<uint8_t> DebugH);
   50 ArrayRef<uint8_t> toDebugH(const DebugHSection &DebugH,

   53 std::vector<LeafRecord> fromDebugT(ArrayRef<uint8_t> DebugTorP,
   55 ArrayRef<uint8_t> toDebugT(ArrayRef<LeafRecord>, BumpPtrAllocator &Alloc,

   69   uint8_t AddrSize;
   70   uint8_t SegSize;
  105   uint8_t AddrSize;
  131   uint8_t MinInstLength;
  132   uint8_t MaxOpsPerInst;
  133   uint8_t DefaultIsStmt;
  134   uint8_t LineBase;
  135   uint8_t LineRange;
  136   uint8_t OpcodeBase;
  137   std::vector<uint8_t> StandardOpcodeLengths;

  110   Optional<uint8_t> Other;

   71   uint8_t n_sect;
   78   uint8_t Imm;
   84   uint8_t Imm;

  117                            ArrayRef<uint8_t> ThreadContext)
  152   RawContentStream(minidump::StreamType Type, ArrayRef<uint8_t> Content = {})

   38   uint8_t NumberOfAuxEntries; // Number of auxiliary entries

   68   ArrayRef<uint8_t> Data;
   75   BinaryRef(ArrayRef<uint8_t> Data) : Data(Data), DataIsHexString(false) {}
   80   ArrayRef<uint8_t>::size_type binary_size() const {

  213                                  uint8_t BytesInAddress,

  298   uint8_t SiteCountArray[1];
  469                   sizeof(uint8_t) * NumValueSites;

  205   const uint8_t *ValueDataStart;
  251   inline uint8_t getNumPaddingBytes(uint64_t SizeInBytes) {

  665   std::error_code read(const uint8_t *Data, uint64_t ListSize);

  504   std::error_code readFuncProfile(const uint8_t *Start);
  519   const uint8_t *Data = nullptr;
  522   const uint8_t *End = nullptr;
  569   std::error_code decompressSection(const uint8_t *SecStart,
  571                                     const uint8_t *&DecompressBuf,
  583   virtual std::error_code readOneSection(const uint8_t *Start, uint64_t Size,
  604   virtual std::error_code readOneSection(const uint8_t *Start, uint64_t Size,

   37   Optional<uint8_t> ContainerType;
   58   Optional<uint8_t> Type;

   42 enum class AccessQualifier : uint8_t {
   51 enum class AddressSpaceQualifier : uint8_t {
   62 enum class ValueKind : uint8_t {
   82 enum class ValueType : uint8_t {

   51 enum : uint8_t {
   59 enum : uint8_t {
   67 enum : uint8_t {
  155   uint8_t reserved0[8];
  157   uint8_t reserved1[20];
  162   uint8_t reserved2[6];

   32   uint64_t ParseInteger(const uint8_t *Data, uint32_t &Offset);
   33   StringRef ParseString(const uint8_t *Data, uint32_t &Offset);
   35   void IntegerAttribute(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   37   void StringAttribute(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   42   void CPU_arch(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   44   void CPU_arch_profile(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   46   void ARM_ISA_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   48   void THUMB_ISA_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   50   void FP_arch(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   52   void WMMX_arch(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   54   void Advanced_SIMD_arch(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   56   void MVE_arch(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   58   void PCS_config(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   60   void ABI_PCS_R9_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   62   void ABI_PCS_RW_data(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   64   void ABI_PCS_RO_data(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   66   void ABI_PCS_GOT_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   68   void ABI_PCS_wchar_t(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   70   void ABI_FP_rounding(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   72   void ABI_FP_denormal(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   74   void ABI_FP_exceptions(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   76   void ABI_FP_user_exceptions(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   78   void ABI_FP_number_model(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   80   void ABI_align_needed(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   82   void ABI_align_preserved(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   84   void ABI_enum_size(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   86   void ABI_HardFP_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   88   void ABI_VFP_args(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   90   void ABI_WMMX_args(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   92   void ABI_optimization_goals(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   95                                  const uint8_t *Data, uint32_t &Offset);
   96   void compatibility(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
   98   void CPU_unaligned_access(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
  100   void FP_HP_extension(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
  102   void ABI_FP_16bit_format(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
  104   void MPextension_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
  106   void DIV_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
  108   void DSP_extension(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
  110   void T2EE_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
  112   void Virtualization_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
  114   void nodefaults(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
  117   void ParseAttributeList(const uint8_t *Data, uint32_t &Offset,
  119   void ParseIndexList(const uint8_t *Data, uint32_t &Offset,
  120                       SmallVectorImpl<uint8_t> &IndexList);
  121   void ParseSubsection(const uint8_t *Data, uint32_t Length);
  127   void Parse(ArrayRef<uint8_t> Section, bool isLittle);

  147   uint8_t Reg() const {
  323   uint8_t ResARM() const {
  327   uint8_t ResAArch64() const {
  332   uint8_t Condition() const {
  337   uint8_t EpilogueStartIndexARM() const {
  368   uint8_t Vers() const {
  394   uint8_t CodeWords() const {
  409   ArrayRef<uint8_t> UnwindByteCode() const {
  412     const uint8_t *ByteCode =

   42   uint8_t ShiftValue = 0; /// The log2 of the required alignment.
   64     uint8_t Log;

   72     uint8_t Index;
   73     explicit Capacity(uint8_t idx) : Index(idx) {}

   34   BinaryByteStream(ArrayRef<uint8_t> Data, llvm::support::endianness Endian)
   42                   ArrayRef<uint8_t> &Buffer) override {
   50                                    ArrayRef<uint8_t> &Buffer) override {
   59   ArrayRef<uint8_t> data() const { return Data; }
   68   ArrayRef<uint8_t> Data;
   92   MutableBinaryByteStream(MutableArrayRef<uint8_t> Data,
  101                   ArrayRef<uint8_t> &Buffer) override {
  106                                    ArrayRef<uint8_t> &Buffer) override {
  112   Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Buffer) override {
  119     uint8_t *DataPtr = const_cast<uint8_t *>(Data.data());
  126   MutableArrayRef<uint8_t> data() const { return Data; }
  129   MutableArrayRef<uint8_t> Data;
  136   std::vector<uint8_t> Data;
  149                   ArrayRef<uint8_t> &Buffer) override {
  157   void insert(uint32_t Offset, ArrayRef<uint8_t> Bytes) {
  162                                    ArrayRef<uint8_t> &Buffer) override {
  172   Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Buffer) override {
  200   MutableArrayRef<uint8_t> data() { return Data; }
  225     uint8_t *getBufferStart() const { return FileBuffer->getBufferStart(); }
  228     uint8_t *getBufferEnd() const { return FileBuffer->getBufferEnd(); }
  244                   ArrayRef<uint8_t> &Buffer) override {
  249                                    ArrayRef<uint8_t> &Buffer) override {
  255   Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Data) override {
  262   uint8_t *getBufferStart() const { return Impl.getBufferStart(); }
  265   uint8_t *getBufferEnd() const { return Impl.getBufferEnd(); }

   23   static ArrayRef<uint8_t> bytes(const T &Item) = delete;
   42                   ArrayRef<uint8_t> &Buffer) override {
   56                                    ArrayRef<uint8_t> &Buffer) override {

   45                           ArrayRef<uint8_t> &Buffer) = 0;
   50                                            ArrayRef<uint8_t> &Buffer) = 0;
   80   virtual Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Data) = 0;

  282     ArrayRef<uint8_t> Data;

   36   explicit BinaryStreamReader(ArrayRef<uint8_t> Data,
   57   Error readLongestContiguousChunk(ArrayRef<uint8_t> &Buffer);
   66   Error readBytes(ArrayRef<uint8_t> &Buffer, uint32_t Size);
   79     ArrayRef<uint8_t> Bytes;
  170     ArrayRef<uint8_t> Buffer;
  188     ArrayRef<uint8_t> Bytes;
  269   uint8_t peek() const;

  169   explicit BinaryStreamRef(ArrayRef<uint8_t> Data,
  189                   ArrayRef<uint8_t> &Buffer) const;
  197                                    ArrayRef<uint8_t> &Buffer) const;
  244   explicit WritableBinaryStreamRef(MutableArrayRef<uint8_t> Data,
  263   Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Data) const;

   36   explicit BinaryStreamWriter(MutableArrayRef<uint8_t> Data,
   56   Error writeBytes(ArrayRef<uint8_t> Buffer);
   67     uint8_t Buffer[sizeof(T)];
  159         ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(Array.data()),

   22 uint32_t crc32(ArrayRef<uint8_t> Data);
   26 uint32_t crc32(uint32_t CRC, ArrayRef<uint8_t> Data);
   50   void update(ArrayRef<uint8_t> Data);

   20   uint8_t Bytes[3];
   21   Uint24(uint8_t U) {
   24   Uint24(uint8_t U0, uint8_t U1, uint8_t U2) {
   24   Uint24(uint8_t U0, uint8_t U1, uint8_t U2) {
   24   Uint24(uint8_t U0, uint8_t U1, uint8_t U2) {
   43   uint8_t IsLittleEndian;
   44   uint8_t AddressSize;
   83   DataExtractor(StringRef Data, bool IsLittleEndian, uint8_t AddressSize)
   85   DataExtractor(ArrayRef<uint8_t> Data, bool IsLittleEndian,
   86                 uint8_t AddressSize)
   96   uint8_t getAddressSize() const { return AddressSize; }
   98   void setAddressSize(uint8_t Size) { AddressSize = Size; }
  255   uint8_t getU8(uint64_t *offset_ptr, Error *Err = nullptr) const;
  260   uint8_t getU8(Cursor &C) const { return getU8(&C.Offset, &C.Err); }
  285   uint8_t *getU8(uint64_t *offset_ptr, uint8_t *dst, uint32_t count) const;
  285   uint8_t *getU8(uint64_t *offset_ptr, uint8_t *dst, uint32_t count) const;
  291   uint8_t *getU8(Cursor &C, uint8_t *Dst, uint32_t Count) const;
  291   uint8_t *getU8(Cursor &C, uint8_t *Dst, uint32_t Count) const;
  298   void getU8(Cursor &C, SmallVectorImpl<uint8_t> &Dst, uint32_t Count) const {

   50   virtual uint8_t *getBufferStart() const = 0;
   53   virtual uint8_t *getBufferEnd() const = 0;

  216   ArrayRef<uint8_t> Bytes;
  222   uint8_t ByteGroupSize; // How many hex bytes are grouped without spaces
  228   FormattedBytes(ArrayRef<uint8_t> B, uint32_t IL, Optional<uint64_t> O,
  229                  uint32_t NPL, uint8_t BGS, bool U, bool A)
  239 format_bytes(ArrayRef<uint8_t> Bytes, Optional<uint64_t> FirstByteOffset = None,
  240              uint32_t NumPerLine = 16, uint8_t ByteGroupSize = 4,
  247 format_bytes_with_ascii(ArrayRef<uint8_t> Bytes,
  249                         uint32_t NumPerLine = 16, uint8_t ByteGroupSize = 4,

   28     uint8_t Byte = Value & 0x7f;
   41     uint8_t PadValue = Value < 0 ? 0x7f : 0x00;
   52 inline unsigned encodeSLEB128(int64_t Value, uint8_t *p, unsigned PadTo = 0) {
   53   uint8_t *orig_p = p;
   57     uint8_t Byte = Value & 0x7f;
   70     uint8_t PadValue = Value < 0 ? 0x7f : 0x00;
   84     uint8_t Byte = Value & 0x7f;
  104 inline unsigned encodeULEB128(uint64_t Value, uint8_t *p,
  106   uint8_t *orig_p = p;
  109     uint8_t Byte = Value & 0x7f;
  128 inline uint64_t decodeULEB128(const uint8_t *p, unsigned *n = nullptr,
  129                               const uint8_t *end = nullptr,
  131   const uint8_t *orig_p = p;
  161 inline int64_t decodeSLEB128(const uint8_t *p, unsigned *n = nullptr,
  162                              const uint8_t *end = nullptr,
  164   const uint8_t *orig_p = p;
  167   uint8_t Byte;

  235   static uint64_t maskAndShift(uint64_t Val, uint64_t Mask, uint8_t Shift) {

   51   uint8_t buffer[64];
   56     std::array<uint8_t, 16> Bytes;
   58     operator std::array<uint8_t, 16>() const { return Bytes; }
   60     const uint8_t &operator[](size_t I) const { return Bytes[I]; }
   61     uint8_t &operator[](size_t I) { return Bytes[I]; }
   85   void update(ArrayRef<uint8_t> Data);
   98   static std::array<uint8_t, 16> hash(ArrayRef<uint8_t> Data);
   98   static std::array<uint8_t, 16> hash(ArrayRef<uint8_t> Data);
  101   const uint8_t *body(ArrayRef<uint8_t> Data);
  101   const uint8_t *body(ArrayRef<uint8_t> Data);

   32     enum SimpleValueType : uint8_t {

  214       LE.write<uint8_t>(0);

   36   void update(ArrayRef<uint8_t> Data);
   57   static std::array<uint8_t, 20> hash(ArrayRef<uint8_t> Data);
   57   static std::array<uint8_t, 20> hash(ArrayRef<uint8_t> Data);
   68       uint8_t C[BLOCK_LENGTH];
   73     uint8_t BufferOffset;
   80   void writebyte(uint8_t data);
   82   void addUncounted(uint8_t data);

  174   void printNumber(StringRef Label, uint8_t Value) {
  277   void printBinary(StringRef Label, StringRef Str, ArrayRef<uint8_t> Value) {
  287   void printBinary(StringRef Label, ArrayRef<uint8_t> Value) {
  303   void printBinaryBlock(StringRef Label, ArrayRef<uint8_t> Value,
  308   void printBinaryBlock(StringRef Label, ArrayRef<uint8_t> Value) {
  345   void printBinaryImpl(StringRef Label, StringRef Str, ArrayRef<uint8_t> Value,

   64     using VariableSizeOffsets = PointerUnion4<std::vector<uint8_t> *,

   61     uint8_t CodeOffset;
   62     uint8_t UnwindOpAndOpInfo;
   66   uint8_t getUnwindOp() const {
   69   uint8_t getOpInfo() const {
   95   uint8_t VersionAndFlags;
   96   uint8_t PrologSize;
   97   uint8_t NumCodes;
   98   uint8_t FrameRegisterAndOffset;
  101   uint8_t getVersion() const {
  104   uint8_t getFlags() const {
  107   uint8_t getFrameRegister() const {
  110   uint8_t getFrameOffset() const {

  449   uint8_t encoding;
  450   uint8_t type;

   41 enum class NodeKind : uint8_t {
 1178   static void output(const uint8_t &, void *, raw_ostream &);
 1179   static StringRef input(StringRef, void *, uint8_t &);

  233   using uuid_t = uint8_t[16];

   46 uint64_t xxHash64(llvm::ArrayRef<uint8_t> Data);

  302   enum InitKind : uint8_t {
  334   uint8_t Opc; // Used by UnOpInit, BinOpInit, and TernOpInit
  343   explicit Init(InitKind K, uint8_t Opc = 0) : Kind(K), Opc(Opc) {}
  429   explicit TypedInit(InitKind K, RecTy *T, uint8_t Opc = 0)
  729   explicit OpInit(InitKind K, RecTy *Type, uint8_t Opc)
  754   enum UnaryOp : uint8_t { CAST, HEAD, TAIL, SIZE, EMPTY };
  803   enum BinaryOp : uint8_t { ADD, MUL, AND, OR, SHL, SRA, SRL, LISTCONCAT,
  861   enum TernaryOp : uint8_t { SUBST, FOREACH, IF, DAG };

   24 enum Architecture : uint8_t {

  240   void setSwiftABIVersion(uint8_t Version) { SwiftABIVersion = Version; }
  243   uint8_t getSwiftABIVersion() const { return SwiftABIVersion; }
  325   void addUUID(const Target &Target, uint8_t UUID[16]);
  401   uint8_t SwiftABIVersion{0};

   25 enum class SymbolFlags : uint8_t {
   49 enum class SymbolKind : uint8_t {

  176   std::vector<uint8_t> Bytes;
  193                 uint64_t &AllocByteOffset, uint8_t &AllocMask);

   40   std::vector<uint8_t> Bytes;
   43   std::vector<uint8_t> BytesUsed;
   45   std::pair<uint8_t *, uint8_t *> getPtrToData(uint64_t Pos, uint8_t Size) {
   45   std::pair<uint8_t *, uint8_t *> getPtrToData(uint64_t Pos, uint8_t Size) {
   45   std::pair<uint8_t *, uint8_t *> getPtrToData(uint64_t Pos, uint8_t Size) {
   55   void setLE(uint64_t Pos, uint64_t Val, uint8_t Size) {
   67   void setBE(uint64_t Pos, uint64_t Val, uint8_t Size) {
  183   void setBeforeBytes(uint64_t Pos, uint8_t Size) {
  192   void setAfterBytes(uint64_t Pos, uint8_t Size) {

   66 SmallVector<uint8_t, 64>
   73 SmallVector<uint8_t, 64> GetShadowBytesAfterScope(

  328                        uint8_t DIExprFlags, int Offset);
  337                                 DIBuilder &Builder, uint8_t DIExprFlags,

  100 enum class MatchState : uint8_t {

   52 enum AllocType : uint8_t {

  645 Optional<uint8_t> llvm::dwarf::getFixedFormByteSize(dwarf::Form Form,

   32   uint8_t FB = static_cast<uint8_t>(*Current++);
   60     return readUInt<uint8_t>(Obj);
   90     return readRaw<uint8_t>(Obj);
   99     return readRaw<uint8_t>(Obj);
  135     return readExt<uint8_t>(Obj);
  161     uint8_t Size = FB & ~FixBitsMask::String;

  462   ArrayRef<uint8_t> Bytes = Stream.getBitcodeBytes();

 2472         SmallVector<uint8_t, 16> Elts(Record.begin(), Record.end());

   27   static const uint8_t AddrSize = Asm.getDataLayout().getPointerSize();

 3180                             SledKind Kind, uint8_t Version) {

   32   virtual void EmitInt8(uint8_t Byte, const Twine &Comment = "") = 0;
   43   void EmitInt8(uint8_t Byte, const Twine &Comment) override {
   62   void EmitInt8(uint8_t Byte, const Twine &Comment) override {
   88   void EmitInt8(uint8_t Byte, const Twine &Comment) override {

  244     ArrayRef<uint8_t> ChecksumAsBytes;
 1779   uint8_t SizeInBytes = Ty->getSizeInBits() / 8;
 3113     uint8_t data[10];

  316 DIEUnit::DIEUnit(uint16_t V, uint8_t A, dwarf::Tag UnitTag)
  436   if (Optional<uint8_t> FixedSize = dwarf::getFixedFormByteSize(Form, Params))

   57     uint8_t Byte = Value & 0x7f;
   69     uint8_t Byte = Value & 0x7f;

   57   void update(uint8_t Value) { Hash.update(Value); }

  172 void DebugLocDwarfExpression::emitOp(uint8_t Op, const char *Comment) {
  186 void DebugLocDwarfExpression::emitData1(uint8_t Value) {

  164   Optional<uint8_t> TagOffset;
  179   virtual void emitOp(uint8_t Op, const char *Comment = nullptr) = 0;
  187   virtual void emitData1(uint8_t Value) = 0;
  360   void emitOp(uint8_t Op, const char *Comment = nullptr) override;
  363   void emitData1(uint8_t Value) override;
  389   void emitOp(uint8_t Op, const char *Comment = nullptr) override;
  392   void emitData1(uint8_t Value) override;

   53 void DIEDwarfExpression::emitOp(uint8_t Op, const char* Comment) {
   65 void DIEDwarfExpression::emitData1(uint8_t Value) {
  582     uint8_t c;
  981     uint8_t CC = 0;

   53                                         uint8_t StackID) {

 1008                                                 int64_t Offset, uint8_t ID) {

  237   uint8_t CutOffInfo;
 2780     uint8_t CutOffEncountered = CutOffInfo & (CO_Depth | CO_Interf);

   71   uint8_t SignBit;

  272   uint8_t StackID = MFI->getStackID(FI);

 1135 std::pair<const TargetRegisterClass *, uint8_t>
 1369     uint8_t Cost;
 1853                                 uint8_t &Value) {
 1888     uint8_t RefSteps;
 1915     uint8_t RefSteps;
 1948     uint8_t RefSteps;
 1969     uint8_t RefSteps;

   71 ArrayRef<ArrayRef<uint8_t>> AppendingTypeTableBuilder::records() const {
   78 AppendingTypeTableBuilder::insertRecordBytes(ArrayRef<uint8_t> &Record) {
   80   uint8_t *Stable = RecordStorage.Allocate<uint8_t>(Record.size());
   80   uint8_t *Stable = RecordStorage.Allocate<uint8_t>(Record.size());

  185   FieldListVisitHelper(TypeVisitorCallbacks &Callbacks, ArrayRef<uint8_t> Data,
  262                                         ArrayRef<uint8_t> Record,
  270 Error llvm::codeview::visitMemberRecordStream(ArrayRef<uint8_t> FieldList,

   91   uint8_t Leaf = Reader->peek();
  100 Error CodeViewRecordIO::mapByteVectorTail(ArrayRef<uint8_t> &Bytes,
  116 Error CodeViewRecordIO::mapByteVectorTail(std::vector<uint8_t> &Bytes,
  118   ArrayRef<uint8_t> BytesRef(Bytes);
  241     ArrayRef<uint8_t> GuidBytes;
  258     uint8_t FinalZero = 0;

   28     uint8_t Pad = static_cast<uint8_t>(LF_PAD0 + PaddingBytes);
   65   const uint8_t *FLIB = reinterpret_cast<const uint8_t *>(FLI);
  153   MutableArrayRef<uint8_t> Data = Buffer.data();

   29   uint8_t ChecksumSize;       // Number of bytes of checksum.
   30   uint8_t ChecksumKind;       // FileChecksumKind
   69                                            ArrayRef<uint8_t> Bytes) {
   72     uint8_t *Copy = Storage.Allocate<uint8_t>(Bytes.size());
   72     uint8_t *Copy = Storage.Allocate<uint8_t>(Bytes.size());

   57 static const EnumEntry<uint8_t> ProcSymFlagNames[] = {
   82 static const EnumEntry<uint8_t> FrameCookieKinds[] = {
  249 static const EnumEntry<uint8_t> ThunkOrdinalNames[] = {
  318 static const EnumEntry<uint8_t> MemberAccessNames[] = {
  343 static const EnumEntry<uint8_t> PtrKindNames[] = {
  359 static const EnumEntry<uint8_t> PtrModeNames[] = {
  387 static const EnumEntry<uint8_t> CallingConventions[] = {
  414 static const EnumEntry<uint8_t> FunctionOptionEnum[] = {
  447 ArrayRef<EnumEntry<uint8_t>> getProcSymFlagNames() {
  455 ArrayRef<EnumEntry<uint8_t>> getFrameCookieKindNames() {
  491 ArrayRef<EnumEntry<uint8_t>> getThunkOrdinalNames() {
  508 ArrayRef<EnumEntry<uint8_t>> getMemberAccessNames() {
  520 ArrayRef<EnumEntry<uint8_t>> getPtrKindNames() {
  524 ArrayRef<EnumEntry<uint8_t>> getPtrModeNames() {
  536 ArrayRef<EnumEntry<uint8_t>> getCallingConventions() {
  540 ArrayRef<EnumEntry<uint8_t>> getFunctionOptionEnum() {

   23 GuidAdapter::GuidAdapter(ArrayRef<uint8_t> Guid)
   32     uint8_t Byte = Item[i];
   33     uint8_t HighNibble = (Byte >> 4) & 0xF;
   34     uint8_t LowNibble = Byte & 0xF;

   74 ArrayRef<ArrayRef<uint8_t>> GlobalTypeTableBuilder::records() const {
   87 TypeIndex GlobalTypeTableBuilder::insertRecordBytes(ArrayRef<uint8_t> Record) {

   45 LazyRandomTypeCollection::LazyRandomTypeCollection(ArrayRef<uint8_t> Data,
   77 void LazyRandomTypeCollection::reset(ArrayRef<uint8_t> Data,

   74 ArrayRef<ArrayRef<uint8_t>> MergingTypeTableBuilder::records() const {
   83 static inline ArrayRef<uint8_t> stabilize(BumpPtrAllocator &Alloc,
   84                                           ArrayRef<uint8_t> Data) {
   85   uint8_t *Stable = Alloc.Allocate<uint8_t>(Data.size());
   85   uint8_t *Stable = Alloc.Allocate<uint8_t>(Data.size());
   91                                                   ArrayRef<uint8_t> &Record) {
   99     ArrayRef<uint8_t> RecordData = stabilize(RecordStorage, Record);
  111 MergingTypeTableBuilder::insertRecordBytes(ArrayRef<uint8_t> &Record) {

   27 StringRef llvm::codeview::getBytesAsCharacters(ArrayRef<uint8_t> LeafData) {
   32 StringRef llvm::codeview::getBytesAsCString(ArrayRef<uint8_t> LeafData) {
  105   ArrayRef<uint8_t> Bytes(Data.bytes_begin(), Data.bytes_end());
  131   ArrayRef<uint8_t> Bytes(Data.bytes_begin(), Data.bytes_end());

   13     uint8_t Pad = static_cast<uint8_t>(LF_PAD0 + PaddingBytes);
   24 ArrayRef<uint8_t> SimpleTypeSerializer::serialize(T &Record) {

   89   uint8_t Padding = 0;
  147   uint8_t Reserved = 0;

   53   uint8_t *StableStorage = Storage.Allocate<uint8_t>(RecordEnd);
   53   uint8_t *StableStorage = Storage.Allocate<uint8_t>(RecordEnd);

   46 static const EnumEntry<uint8_t> MemberAccessNames[] = {
   69 static const EnumEntry<uint8_t> PtrKindNames[] = {
   85 static const EnumEntry<uint8_t> PtrModeNames[] = {
  110 static const EnumEntry<uint8_t> CallingConventions[] = {
  137 static const EnumEntry<uint8_t> FunctionOptionEnum[] = {

   20 static std::array<uint8_t, 8> EmptyHash = {
   22 static std::array<uint8_t, 8> TombstoneHash = {
   28 LocallyHashedType LocallyHashedType::hashType(ArrayRef<uint8_t> RecordData) {
   33 GloballyHashedType::hashType(ArrayRef<uint8_t> RecordData,
   46     ArrayRef<uint8_t> PreData = RecordData.slice(Off, PreLen);
   56       ArrayRef<uint8_t> BytesToHash;
   58         const uint8_t *IndexBytes = reinterpret_cast<const uint8_t *>(&TI);

   39 static inline uint32_t getEncodedIntegerLength(ArrayRef<uint8_t> Data) {
   63 static inline uint32_t getCStringLength(ArrayRef<uint8_t> Data) {
   68 static void handleMethodOverloadList(ArrayRef<uint8_t> Content,
   94 static uint32_t handleBaseClass(ArrayRef<uint8_t> Data, uint32_t Offset,
  104 static uint32_t handleEnumerator(ArrayRef<uint8_t> Data, uint32_t Offset,
  114 static uint32_t handleDataMember(ArrayRef<uint8_t> Data, uint32_t Offset,
  126 static uint32_t handleOverloadedMethod(ArrayRef<uint8_t> Data, uint32_t Offset,
  136 static uint32_t handleOneMethod(ArrayRef<uint8_t> Data, uint32_t Offset,
  154 static uint32_t handleNestedType(ArrayRef<uint8_t> Data, uint32_t Offset,
  164 static uint32_t handleStaticDataMember(ArrayRef<uint8_t> Data, uint32_t Offset,
  174 static uint32_t handleVirtualBaseClass(ArrayRef<uint8_t> Data, uint32_t Offset,
  190 static uint32_t handleVFPtr(ArrayRef<uint8_t> Data, uint32_t Offset,
  199 static uint32_t handleListContinuation(ArrayRef<uint8_t> Data, uint32_t Offset,
  208 static void handleFieldList(ArrayRef<uint8_t> Content,
  254       uint8_t Pad = Content.front();
  264 static void handlePointer(ArrayRef<uint8_t> Content,
  273 static void discoverTypeIndices(ArrayRef<uint8_t> Content, TypeLeafKind Kind,
  359 static bool discoverTypeIndices(ArrayRef<uint8_t> Content, SymbolKind Kind,
  461 static void resolveTypeIndexReferences(ArrayRef<uint8_t> RecordData,
  485 void llvm::codeview::discoverTypeIndices(ArrayRef<uint8_t> RecordData,
  492 void llvm::codeview::discoverTypeIndices(ArrayRef<uint8_t> RecordData,
  507     ArrayRef<uint8_t> RecordData, SmallVectorImpl<TiReference> &Refs) {
  516     ArrayRef<uint8_t> RecordData, SmallVectorImpl<TypeIndex> &Indices) {

  460       uint8_t Byte = static_cast<uint8_t>(Slots[SlotIndex]) << 4;
  469       uint8_t Byte;

  134   ArrayRef<uint8_t> remapIndices(const CVType &OriginalType,
  135                                  MutableArrayRef<uint8_t> Storage);
  196   SmallVector<uint8_t, 256> RemapStorage;
  359   ArrayRef<uint8_t> Buffer;
  387       ArrayRef<uint8_t> Result = DoSerialize(RemapStorage);
  400 ArrayRef<uint8_t>
  402                                MutableArrayRef<uint8_t> Storage) {
  411   uint8_t *DestContent = Storage.data() + sizeof(RecordPrefix);

   18 TypeTableCollection::TypeTableCollection(ArrayRef<ArrayRef<uint8_t>> Records)

   54   uint8_t ChildrenByte = Data.getU8(OffsetPtr);
   72       Optional<uint8_t> ByteSize;

  245                             uint8_t AddrSize) {
  515     uint8_t savedAddressByteSize = getCUAddrSize();
 1039       if (Optional<ArrayRef<uint8_t>> Location = LocationAttr->getAsBlock())
 1365   uint8_t AddressSize;
 1487                    uint8_t AddrSize, bool IsLittleEndian)
 1801   uint8_t getAddressSize() const override { return AddressSize; }
 1825                      uint8_t AddrSize, bool isLittleEndian) {
 1848 uint8_t DWARFContext::getCUAddrSize() {
 1854   uint8_t Addr = 0;

   35 DWARFDataExtractor::getEncodedPointer(uint64_t *Offset, uint8_t Encoding,

   24                                    uint8_t AddrSize,

   34 const uint8_t DWARF_CFI_PRIMARY_OPCODE_MASK = 0xc0;
   35 const uint8_t DWARF_CFI_PRIMARY_OPERAND_MASK = 0x3f;
   40     uint8_t Opcode = Data.getRelocatedValue(1, Offset);
   42     uint8_t Primary = Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK;
  221   uint8_t Opcode = Instr.Opcode;
  277     uint8_t Opcode = Instr.Opcode;
  306     for (uint8_t Byte : AugmentationData)
  337     uint8_t c = Data.getU8(&Offset);
  388       uint8_t Version = Data.getU8(&Offset);
  391       uint8_t AddressSize = Version < 4 ? Data.getAddressSize() :
  394       uint8_t SegmentDescriptorSize = Version < 4 ? 0 : Data.getU8(&Offset);

  371     uint8_t OpLen = DebugLineData.getU8(OffsetPtr);
  567     uint8_t Opcode = DebugLineData.getU8(OffsetPtr);
  585       uint8_t SubOpcode = DebugLineData.getU8(OffsetPtr);
  770           uint8_t AdjustOpcode = 255 - Prologue.OpcodeBase;
  825           uint8_t OpcodeLength = Prologue.StandardOpcodeLengths[Opcode - 1];
  826           for (uint8_t I = 0; I < OpcodeLength; ++I) {
  869       uint8_t AdjustOpcode = Opcode - Prologue.OpcodeBase;

   31 static void dumpExpression(raw_ostream &OS, ArrayRef<uint8_t> Data,

   40       uint8_t IndexEntryValue = GnuStyle ? PubNames.getU8(&Offset) : 0;

   27   uint8_t Encoding = Data.getU8(OffsetPtr);
  174     raw_ostream &OS, uint8_t AddrSize, uint8_t MaxEncodingStringLength,
  174     raw_ostream &OS, uint8_t AddrSize, uint8_t MaxEncodingStringLength,

   86     ArrayRef<uint8_t> Expr = *FormValue.getAsBlock();

  117 static uint8_t getRefAddrSize(uint8_t AddrSize, uint16_t Version) {
  117 static uint8_t getRefAddrSize(uint8_t AddrSize, uint16_t Version) {
  122                                          uint8_t AddressSize, uint64_t Offset) {
  205 static bool prettyPrintRegisterOp(raw_ostream &OS, uint8_t Opcode,

   93                                                     ArrayRef<uint8_t> D) {
  123       uint8_t size = DebugInfoData.getU8(OffsetPtr);
  171       if (Optional<uint8_t> FixedSize =
  468       const uint8_t *DataPtr = Value.data;
  471         const uint8_t *EndDataPtr = DataPtr + UValue;
  703 Optional<ArrayRef<uint8_t>> DWARFFormValue::getAsBlock() const {

   28   uint8_t OffsetByteSize = 4;

  780   uint8_t EntrySize = getDwarfOffsetByteSize();
  802   uint8_t Version = DA.getU16(&Offset);
  820   uint8_t Version = DA.getU16(&Offset);

  102                                      uint8_t &UnitType, bool &isUnitDWARF64) {
  104   uint8_t AddrSize = 0;
  191   uint8_t UnitType = Unit.getUnitType();
  279   uint8_t UnitType = 0;
  482     if (Optional<ArrayRef<uint8_t>> Expr = AttrValue.Value.getAsBlock()) {
 1296   if (Optional<ArrayRef<uint8_t>> Expr = Location->getAsBlock()) {

   21   uint8_t Bytes[32];
   28   uint8_t Bytes[32];
   34 void FileWriter::writeU8(uint8_t U) {
   59 void FileWriter::writeData(llvm::ArrayRef<uint8_t> Data) {

  212   case 1: return addressForIndex<uint8_t>(Index);
  234   case 1: return getAddressOffsetIndex<uint8_t>(AddrOffset);

   34   for (uint8_t I = 0; I < H.UUIDSize; ++I)

   36                           uint8_t &SpecialOp) {
   76     uint8_t Op = Data.getU8(&Offset);
  107         uint8_t AdjustedOp = Op - FirstSpecial;
  223     uint8_t SpecialOp;

  325     uint8_t ThisByte = 0;
  329       uint8_t Mask = uint8_t(IsFree) << I;

   89                                    ArrayRef<uint8_t> &Buffer) {
  151   uint8_t *WriteBuffer = static_cast<uint8_t *>(Allocator.Allocate(Size, 8));
  167                                                     ArrayRef<uint8_t> &Buffer) {
  186   ArrayRef<uint8_t> BlockData;
  199                                             ArrayRef<uint8_t> &Buffer) {
  227   ArrayRef<uint8_t> BlockData;
  240                                    MutableArrayRef<uint8_t> Buffer) {
  250   uint8_t *WriteBuffer = Buffer.data();
  254     ArrayRef<uint8_t> BlockData;
  259     const uint8_t *ChunkStart = BlockData.data() + OffsetInBlock;
  275                                            ArrayRef<uint8_t> Data) const {
  366   std::vector<uint8_t> InitData(Layout.SB->BlockSize, 0xFF);
  374                                            ArrayRef<uint8_t> &Buffer) {
  379     uint32_t Offset, ArrayRef<uint8_t> &Buffer) {
  388                                             ArrayRef<uint8_t> Buffer) {
  403     const uint8_t *Chunk = Buffer.data() + BytesWritten;
  404     ArrayRef<uint8_t> ChunkData(Chunk, BytesToWriteInChunk);

   29     for (uint8_t c : Checksum)

   72     ArrayRef<uint8_t> BulkSymbols) {
  158     for (ArrayRef<uint8_t> Syms : Symbols) {

   40 void DbiStreamBuilder::setBuildNumber(uint8_t Major, uint8_t Minor) {
   40 void DbiStreamBuilder::setBuildNumber(uint8_t Major, uint8_t Minor) {
   89                                      ArrayRef<uint8_t> Data) {
  190   auto Data = Allocator.Allocate<uint8_t>(Size);

   40           DenseMapInfo<ArrayRef<uint8_t>>::getTombstoneKey());

  147     uint8_t WordIdx = I / 32;
  148     uint8_t BitIdx = I % 32;

   30   const uint8_t *Remainder = reinterpret_cast<const uint8_t *>(Longs.end());
   70   for (uint8_t Item : Buffer) {
   80 uint32_t pdb::hashBufferV8(ArrayRef<uint8_t> Buf) {

   25     ArrayRef<uint8_t> Data;

   97 void NativeRawSymbol::getDataBytes(SmallVector<uint8_t, 32> &bytes) const {

  104 Expected<ArrayRef<uint8_t>> PDBFile::getBlockData(uint32_t BlockIndex,
  108   ArrayRef<uint8_t> Result;
  115                             ArrayRef<uint8_t> Data) const {
  157   ArrayRef<uint8_t> FpmBytes;