1 //===--------------------AMDKernelCodeTUtils.cpp --------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 //===----------------------------------------------------------------------===// 11 // 12 /// \file - utility functions to parse/print amd_kernel_code_t structure 13 // 14 //===----------------------------------------------------------------------===// 15 16 #include "AMDKernelCodeTUtils.h" 17 #include "SIDefines.h" 18 #include <llvm/MC/MCParser/MCAsmLexer.h> 19 #include <llvm/Support/raw_ostream.h> 20 21 using namespace llvm; 22 23 static ArrayRef<StringRef> get_amd_kernel_code_t_FldNames() { 24 static StringRef const Table[] = { 25 "", // not found placeholder 26 #define RECORD(name, print, parse) #name 27 #include "AMDKernelCodeTInfo.h" 28 #undef RECORD 29 }; 30 return makeArrayRef(Table); 31 } 32 33 static StringMap<int> createIndexMap(const ArrayRef<StringRef> &a) { 34 StringMap<int> map; 35 for (auto Name : a) 36 map.insert(std::make_pair(Name, map.size())); 37 return map; 38 } 39 40 static int get_amd_kernel_code_t_FieldIndex(StringRef name) { 41 static const auto map = createIndexMap(get_amd_kernel_code_t_FldNames()); 42 return map.lookup(name) - 1; // returns -1 if not found 43 } 44 45 static StringRef get_amd_kernel_code_t_FieldName(int index) { 46 return get_amd_kernel_code_t_FldNames()[index + 1]; 47 } 48 49 50 // Field printing 51 52 static raw_ostream &printName(raw_ostream &OS, StringRef Name) { 53 return OS << Name << " = "; 54 } 55 56 template <typename T, T amd_kernel_code_t::*ptr> 57 static void printField(StringRef Name, const amd_kernel_code_t &C, 58 raw_ostream &OS) { 59 printName(OS, Name) << (int)(C.*ptr); 60 } 61 62 template <typename T, T amd_kernel_code_t::*ptr, int shift, int width = 1> 63 static void printBitField(StringRef Name, const amd_kernel_code_t &c, 64 raw_ostream &OS) { 65 const auto Mask = (static_cast<T>(1) << width) - 1; 66 printName(OS, Name) << (int)((c.*ptr >> shift) & Mask); 67 } 68 69 typedef void(*PrintFx)(StringRef, 70 const amd_kernel_code_t &, 71 raw_ostream &); 72 73 static ArrayRef<PrintFx> getPrinterTable() { 74 static const PrintFx Table[] = { 75 #define RECORD(name, print, parse) print 76 #include "AMDKernelCodeTInfo.h" 77 #undef RECORD 78 }; 79 return makeArrayRef(Table); 80 } 81 82 void llvm::printAmdKernelCodeField(const amd_kernel_code_t &C, 83 int FldIndex, 84 raw_ostream &OS) { 85 auto Printer = getPrinterTable()[FldIndex]; 86 if (Printer) 87 Printer(get_amd_kernel_code_t_FieldName(FldIndex), C, OS); 88 } 89 90 void llvm::dumpAmdKernelCode(const amd_kernel_code_t *C, 91 raw_ostream &OS, 92 const char *tab) { 93 const int Size = getPrinterTable().size(); 94 for (int i = 0; i < Size; ++i) { 95 OS << tab; 96 printAmdKernelCodeField(*C, i, OS); 97 OS << '\n'; 98 } 99 } 100 101 102 // Field parsing 103 104 static bool expectEqualInt(MCAsmLexer &Lexer, raw_ostream &Err) { 105 if (Lexer.isNot(AsmToken::Equal)) { 106 Err << "expected '='"; 107 return false; 108 } 109 Lexer.Lex(); 110 if (Lexer.isNot(AsmToken::Integer)) { 111 Err << "integer literal expected"; 112 return false; 113 } 114 return true; 115 } 116 117 template <typename T, T amd_kernel_code_t::*ptr> 118 static bool parseField(amd_kernel_code_t &C, MCAsmLexer &Lexer, 119 raw_ostream &Err) { 120 if (!expectEqualInt(Lexer, Err)) 121 return false; 122 C.*ptr = (T)Lexer.getTok().getIntVal(); 123 return true; 124 } 125 126 template <typename T, T amd_kernel_code_t::*ptr, int shift, int width = 1> 127 static bool parseBitField(amd_kernel_code_t &C, MCAsmLexer &Lexer, 128 raw_ostream &Err) { 129 if (!expectEqualInt(Lexer, Err)) 130 return false; 131 const uint64_t Mask = ((UINT64_C(1) << width) - 1) << shift; 132 C.*ptr &= (T)~Mask; 133 C.*ptr |= (T)((Lexer.getTok().getIntVal() << shift) & Mask); 134 return true; 135 } 136 137 typedef bool(*ParseFx)(amd_kernel_code_t &, 138 MCAsmLexer &Lexer, 139 raw_ostream &Err); 140 141 static ArrayRef<ParseFx> getParserTable() { 142 static const ParseFx Table[] = { 143 #define RECORD(name, print, parse) parse 144 #include "AMDKernelCodeTInfo.h" 145 #undef RECORD 146 }; 147 return makeArrayRef(Table); 148 } 149 150 bool llvm::parseAmdKernelCodeField(StringRef ID, 151 MCAsmLexer &Lexer, 152 amd_kernel_code_t &C, 153 raw_ostream &Err) { 154 const int Idx = get_amd_kernel_code_t_FieldIndex(ID); 155 if (Idx < 0) { 156 Err << "unexpected amd_kernel_code_t field name " << ID; 157 return false; 158 } 159 auto Parser = getParserTable()[Idx]; 160 return Parser ? Parser(C, Lexer, Err) : false; 161 } 162