1 //===-- CTFTypes.h ----------------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_CTF_CTFTYPES_H 10 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_CTF_CTFTYPES_H 11 12 #include "lldb/lldb-types.h" 13 #include "llvm/ADT/StringRef.h" 14 15 namespace lldb_private { 16 17 struct CTFType { 18 enum Kind : uint32_t { 19 eUnknown = 0, 20 eInteger = 1, 21 eFloat = 2, 22 ePointer = 3, 23 eArray = 4, 24 eFunction = 5, 25 eStruct = 6, 26 eUnion = 7, 27 eEnum = 8, 28 eForward = 9, 29 eTypedef = 10, 30 eVolatile = 11, 31 eConst = 12, 32 eRestrict = 13, 33 eSlice = 14, 34 }; 35 36 Kind kind; 37 lldb::user_id_t uid; 38 llvm::StringRef name; 39 40 CTFType(Kind kind, lldb::user_id_t uid, llvm::StringRef name) 41 : kind(kind), uid(uid), name(name) {} 42 }; 43 44 struct CTFInteger : public CTFType { 45 CTFInteger(lldb::user_id_t uid, llvm::StringRef name, uint32_t bits, 46 uint32_t encoding) 47 : CTFType(eInteger, uid, name), bits(bits), encoding(encoding) {} 48 49 static bool classof(const CTFType *T) { return T->kind == eInteger; } 50 51 uint32_t bits; 52 uint32_t encoding; 53 }; 54 55 struct CTFModifier : public CTFType { 56 protected: 57 CTFModifier(Kind kind, lldb::user_id_t uid, uint32_t type) 58 : CTFType(kind, uid, ""), type(type) {} 59 60 static bool classof(const CTFType *T) { 61 return T->kind == ePointer || T->kind == eConst || T->kind == eVolatile || 62 T->kind == eRestrict; 63 } 64 65 public: 66 uint32_t type; 67 }; 68 69 struct CTFPointer : public CTFModifier { 70 CTFPointer(lldb::user_id_t uid, uint32_t type) 71 : CTFModifier(ePointer, uid, type) {} 72 73 static bool classof(const CTFType *T) { return T->kind == ePointer; } 74 }; 75 76 struct CTFConst : public CTFModifier { 77 CTFConst(lldb::user_id_t uid, uint32_t type) 78 : CTFModifier(eConst, uid, type) {} 79 80 static bool classof(const CTFType *T) { return T->kind == eConst; } 81 }; 82 83 struct CTFVolatile : public CTFModifier { 84 CTFVolatile(lldb::user_id_t uid, uint32_t type) 85 : CTFModifier(eVolatile, uid, type) {} 86 87 static bool classof(const CTFType *T) { return T->kind == eVolatile; } 88 }; 89 90 struct CTFRestrict : public CTFModifier { 91 CTFRestrict(lldb::user_id_t uid, uint32_t type) 92 : CTFModifier(eRestrict, uid, type) {} 93 static bool classof(const CTFType *T) { return T->kind == eRestrict; } 94 }; 95 96 struct CTFTypedef : public CTFType { 97 CTFTypedef(lldb::user_id_t uid, llvm::StringRef name, uint32_t type) 98 : CTFType(eTypedef, uid, name), type(type) {} 99 100 static bool classof(const CTFType *T) { return T->kind == eTypedef; } 101 102 uint32_t type; 103 }; 104 105 struct CTFArray : public CTFType { 106 CTFArray(lldb::user_id_t uid, llvm::StringRef name, uint32_t type, 107 uint32_t index, uint32_t nelems) 108 : CTFType(eArray, uid, name), type(type), index(index), nelems(nelems) {} 109 110 static bool classof(const CTFType *T) { return T->kind == eArray; } 111 112 uint32_t type; 113 uint32_t index; 114 uint32_t nelems; 115 }; 116 117 struct CTFEnum : public CTFType { 118 struct Value { 119 Value(llvm::StringRef name, uint32_t value) : name(name), value(value){}; 120 llvm::StringRef name; 121 uint32_t value; 122 }; 123 124 CTFEnum(lldb::user_id_t uid, llvm::StringRef name, uint32_t nelems, 125 uint32_t size, std::vector<Value> values) 126 : CTFType(eEnum, uid, name), nelems(nelems), size(size), 127 values(std::move(values)) { 128 assert(this->values.size() == nelems); 129 } 130 131 static bool classof(const CTFType *T) { return T->kind == eEnum; } 132 133 uint32_t nelems; 134 uint32_t size; 135 std::vector<Value> values; 136 }; 137 138 struct CTFFunction : public CTFType { 139 CTFFunction(lldb::user_id_t uid, llvm::StringRef name, uint32_t nargs, 140 uint32_t return_type, std::vector<uint32_t> args, bool variadic) 141 : CTFType(eFunction, uid, name), nargs(nargs), return_type(return_type), 142 args(std::move(args)), variadic(variadic) {} 143 144 static bool classof(const CTFType *T) { return T->kind == eFunction; } 145 146 uint32_t nargs; 147 uint32_t return_type; 148 149 std::vector<uint32_t> args; 150 bool variadic = false; 151 }; 152 153 struct CTFRecord : public CTFType { 154 public: 155 struct Field { 156 Field(llvm::StringRef name, uint32_t type, uint64_t offset) 157 : name(name), type(type), offset(offset) {} 158 159 llvm::StringRef name; 160 uint32_t type; 161 uint64_t offset; 162 }; 163 164 CTFRecord(Kind kind, lldb::user_id_t uid, llvm::StringRef name, 165 uint32_t nfields, uint32_t size, std::vector<Field> fields) 166 : CTFType(kind, uid, name), nfields(nfields), size(size), 167 fields(std::move(fields)) {} 168 169 static bool classof(const CTFType *T) { 170 return T->kind == eStruct || T->kind == eUnion; 171 } 172 173 uint32_t nfields; 174 uint32_t size; 175 std::vector<Field> fields; 176 }; 177 178 struct CTFStruct : public CTFRecord { 179 CTFStruct(lldb::user_id_t uid, llvm::StringRef name, uint32_t nfields, 180 uint32_t size, std::vector<Field> fields) 181 : CTFRecord(eStruct, uid, name, nfields, size, std::move(fields)){}; 182 183 static bool classof(const CTFType *T) { return T->kind == eStruct; } 184 }; 185 186 struct CTFUnion : public CTFRecord { 187 CTFUnion(lldb::user_id_t uid, llvm::StringRef name, uint32_t nfields, 188 uint32_t size, std::vector<Field> fields) 189 : CTFRecord(eUnion, uid, name, nfields, size, std::move(fields)){}; 190 191 static bool classof(const CTFType *T) { return T->kind == eUnion; } 192 }; 193 194 struct CTFForward : public CTFType { 195 CTFForward(lldb::user_id_t uid, llvm::StringRef name) 196 : CTFType(eForward, uid, name) {} 197 198 static bool classof(const CTFType *T) { return T->kind == eForward; } 199 }; 200 201 } // namespace lldb_private 202 203 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_CTF_CTFTYPES_H 204