| //===-- CTFTypes.h ----------------------------------------------*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_CTF_CTFTYPES_H |
| #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_CTF_CTFTYPES_H |
| |
| #include "lldb/lldb-types.h" |
| #include "llvm/ADT/StringRef.h" |
| |
| namespace lldb_private { |
| |
| struct CTFType { |
| enum Kind : uint32_t { |
| eUnknown = 0, |
| eInteger = 1, |
| eFloat = 2, |
| ePointer = 3, |
| eArray = 4, |
| eFunction = 5, |
| eStruct = 6, |
| eUnion = 7, |
| eEnum = 8, |
| eForward = 9, |
| eTypedef = 10, |
| eVolatile = 11, |
| eConst = 12, |
| eRestrict = 13, |
| eSlice = 14, |
| }; |
| |
| Kind kind; |
| lldb::user_id_t uid; |
| llvm::StringRef name; |
| |
| CTFType(Kind kind, lldb::user_id_t uid, llvm::StringRef name) |
| : kind(kind), uid(uid), name(name) {} |
| }; |
| |
| struct CTFInteger : public CTFType { |
| CTFInteger(lldb::user_id_t uid, llvm::StringRef name, uint32_t bits, |
| uint32_t encoding) |
| : CTFType(eInteger, uid, name), bits(bits), encoding(encoding) {} |
| |
| static bool classof(const CTFType *T) { return T->kind == eInteger; } |
| |
| uint32_t bits; |
| uint32_t encoding; |
| }; |
| |
| struct CTFModifier : public CTFType { |
| protected: |
| CTFModifier(Kind kind, lldb::user_id_t uid, uint32_t type) |
| : CTFType(kind, uid, ""), type(type) {} |
| |
| static bool classof(const CTFType *T) { |
| return T->kind == ePointer || T->kind == eConst || T->kind == eVolatile || |
| T->kind == eRestrict; |
| } |
| |
| public: |
| uint32_t type; |
| }; |
| |
| struct CTFPointer : public CTFModifier { |
| CTFPointer(lldb::user_id_t uid, uint32_t type) |
| : CTFModifier(ePointer, uid, type) {} |
| |
| static bool classof(const CTFType *T) { return T->kind == ePointer; } |
| }; |
| |
| struct CTFConst : public CTFModifier { |
| CTFConst(lldb::user_id_t uid, uint32_t type) |
| : CTFModifier(eConst, uid, type) {} |
| |
| static bool classof(const CTFType *T) { return T->kind == eConst; } |
| }; |
| |
| struct CTFVolatile : public CTFModifier { |
| CTFVolatile(lldb::user_id_t uid, uint32_t type) |
| : CTFModifier(eVolatile, uid, type) {} |
| |
| static bool classof(const CTFType *T) { return T->kind == eVolatile; } |
| }; |
| |
| struct CTFRestrict : public CTFModifier { |
| CTFRestrict(lldb::user_id_t uid, uint32_t type) |
| : CTFModifier(eRestrict, uid, type) {} |
| static bool classof(const CTFType *T) { return T->kind == eRestrict; } |
| }; |
| |
| struct CTFTypedef : public CTFType { |
| CTFTypedef(lldb::user_id_t uid, llvm::StringRef name, uint32_t type) |
| : CTFType(eTypedef, uid, name), type(type) {} |
| |
| static bool classof(const CTFType *T) { return T->kind == eTypedef; } |
| |
| uint32_t type; |
| }; |
| |
| struct CTFArray : public CTFType { |
| CTFArray(lldb::user_id_t uid, llvm::StringRef name, uint32_t type, |
| uint32_t index, uint32_t nelems) |
| : CTFType(eArray, uid, name), type(type), index(index), nelems(nelems) {} |
| |
| static bool classof(const CTFType *T) { return T->kind == eArray; } |
| |
| uint32_t type; |
| uint32_t index; |
| uint32_t nelems; |
| }; |
| |
| struct CTFEnum : public CTFType { |
| struct Value { |
| Value(llvm::StringRef name, uint32_t value) : name(name), value(value){}; |
| llvm::StringRef name; |
| uint32_t value; |
| }; |
| |
| CTFEnum(lldb::user_id_t uid, llvm::StringRef name, uint32_t nelems, |
| uint32_t size, std::vector<Value> values) |
| : CTFType(eEnum, uid, name), nelems(nelems), size(size), |
| values(std::move(values)) { |
| assert(this->values.size() == nelems); |
| } |
| |
| static bool classof(const CTFType *T) { return T->kind == eEnum; } |
| |
| uint32_t nelems; |
| uint32_t size; |
| std::vector<Value> values; |
| }; |
| |
| struct CTFFunction : public CTFType { |
| CTFFunction(lldb::user_id_t uid, llvm::StringRef name, uint32_t nargs, |
| uint32_t return_type, std::vector<uint32_t> args, bool variadic) |
| : CTFType(eFunction, uid, name), nargs(nargs), return_type(return_type), |
| args(std::move(args)), variadic(variadic) {} |
| |
| static bool classof(const CTFType *T) { return T->kind == eFunction; } |
| |
| uint32_t nargs; |
| uint32_t return_type; |
| |
| std::vector<uint32_t> args; |
| bool variadic = false; |
| }; |
| |
| struct CTFRecord : public CTFType { |
| public: |
| struct Field { |
| Field(llvm::StringRef name, uint32_t type, uint64_t offset) |
| : name(name), type(type), offset(offset) {} |
| |
| llvm::StringRef name; |
| uint32_t type; |
| uint64_t offset; |
| }; |
| |
| CTFRecord(Kind kind, lldb::user_id_t uid, llvm::StringRef name, |
| uint32_t nfields, uint32_t size, std::vector<Field> fields) |
| : CTFType(kind, uid, name), nfields(nfields), size(size), |
| fields(std::move(fields)) {} |
| |
| static bool classof(const CTFType *T) { |
| return T->kind == eStruct || T->kind == eUnion; |
| } |
| |
| uint32_t nfields; |
| uint32_t size; |
| std::vector<Field> fields; |
| }; |
| |
| struct CTFStruct : public CTFRecord { |
| CTFStruct(lldb::user_id_t uid, llvm::StringRef name, uint32_t nfields, |
| uint32_t size, std::vector<Field> fields) |
| : CTFRecord(eStruct, uid, name, nfields, size, std::move(fields)){}; |
| |
| static bool classof(const CTFType *T) { return T->kind == eStruct; } |
| }; |
| |
| struct CTFUnion : public CTFRecord { |
| CTFUnion(lldb::user_id_t uid, llvm::StringRef name, uint32_t nfields, |
| uint32_t size, std::vector<Field> fields) |
| : CTFRecord(eUnion, uid, name, nfields, size, std::move(fields)){}; |
| |
| static bool classof(const CTFType *T) { return T->kind == eUnion; } |
| }; |
| |
| struct CTFForward : public CTFType { |
| CTFForward(lldb::user_id_t uid, llvm::StringRef name) |
| : CTFType(eForward, uid, name) {} |
| |
| static bool classof(const CTFType *T) { return T->kind == eForward; } |
| }; |
| |
| } // namespace lldb_private |
| |
| #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_CTF_CTFTYPES_H |