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

Derived Classes

tools/lldb/include/lldb/Symbol/TaggedASTType.h

   18 template <unsigned int C> class TaggedASTType : public CompilerType {

Declarations

tools/lldb/include/lldb/Core/ValueObjectConstResultImpl.h

   21 class CompilerType;

tools/lldb/include/lldb/lldb-forward.h

   67 class CompilerType;

tools/lldb/source/Plugins/SymbolFile/NativePDB/UdtRecordCompleter.h

   33 class CompilerType;

tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.h

   27 class CompilerType;

References

include/llvm/ADT/Optional.h

   39     T value;
   60   explicit OptionalStorage(in_place_t, Args &&... args)
   61       : value(std::forward<Args>(args)...), hasVal(true) {}
   72   T &getValue() LLVM_LVALUE_FUNCTION noexcept {
   76   T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
   81   T &&getValue() && noexcept {
   87   template <class... Args> void emplace(Args &&... args) {
   89     ::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
   89     ::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
  216   optional_detail::OptionalStorage<T> Storage;
  219   using value_type = T;
  224   Optional(const T &y) : Storage(optional_detail::in_place_t{}, y) {}
  227   Optional(T &&y) : Storage(optional_detail::in_place_t{}, std::move(y)) {}
  230   Optional &operator=(T &&y) {
  241   static inline Optional create(const T *y) {
  245   Optional &operator=(const T &y) {
  253   const T *getPointer() const { return &Storage.getValue(); }
  254   T *getPointer() { return &Storage.getValue(); }
  255   const T &getValue() const LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
  256   T &getValue() LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
  260   const T *operator->() const { return getPointer(); }
  261   T *operator->() { return getPointer(); }
  262   const T &operator*() const LLVM_LVALUE_FUNCTION { return getValue(); }
  263   T &operator*() LLVM_LVALUE_FUNCTION { return getValue(); }
  266   constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
  271   T &&getValue() && { return std::move(Storage.getValue()); }
  272   T &&operator*() && { return std::move(Storage.getValue()); }
  275   T getValueOr(U &&value) && {

include/llvm/ADT/SmallSet.h

  138   SmallVector<T, N> Vector;
  139   std::set<T, C> Set;
  141   using VIterator = typename SmallVector<T, N>::const_iterator;
  142   using mutable_iterator = typename SmallVector<T, N>::iterator;
  151   using const_iterator = SmallSetIterator<T, N, C>;
  164   size_type count(const T &V) const {
  180   std::pair<NoneType, bool> insert(const T &V) {
  207   bool erase(const T &V) {
  238   VIterator vfind(const T &V) const {

include/llvm/ADT/SmallVector.h

   75   AlignedCharArrayUnion<T> FirstEl;
  114   using value_type = T;
  115   using iterator = T *;
  116   using const_iterator = const T *;
  121   using reference = T &;
  122   using const_reference = const T &;
  123   using pointer = T *;
  124   using const_pointer = const T *;
  179 class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
  183   static void destroy_range(T *S, T *E) {
  183   static void destroy_range(T *S, T *E) {
  211   void push_back(const T &Elt) {
  214     ::new ((void*) this->end()) T(Elt);
  218   void push_back(T &&Elt) {
  240   T *NewElts = static_cast<T*>(llvm::safe_malloc(NewCapacity*sizeof(T)));
  240   T *NewElts = static_cast<T*>(llvm::safe_malloc(NewCapacity*sizeof(T)));
  315 class SmallVectorImpl : public SmallVectorTemplateBase<T> {
  316   using SuperClass = SmallVectorTemplateBase<T>;
  357   void resize(size_type N, const T &NV) {
  374   LLVM_NODISCARD T pop_back_val() {
  397   void append(size_type NumInputs, const T &Elt) {
  405   void append(std::initializer_list<T> IL) {
  412   void assign(size_type NumElts, const T &Elt) {
  429   void assign(std::initializer_list<T> IL) {
  467   iterator insert(iterator I, T &&Elt) {
  497   iterator insert(iterator I, const T &Elt) {
  526   iterator insert(iterator I, size_type NumToInsert, const T &Elt) {
  637   void insert(iterator I, std::initializer_list<T> IL) {
  820   AlignedCharArrayUnion<T> InlineElts[N];
  837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
  837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
  846   explicit SmallVector(size_t Size, const T &Value = T())
  865   SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
  884   SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {

include/llvm/Support/AlignOf.h

   30   T t;
   39 template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
   50       llvm::detail::SizerImpl<T, Ts...>)];

include/llvm/Support/type_traits.h

   91     T t;
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  145       std::is_copy_constructible<detail::trivial_helper<T>>::value;
  147       !std::is_copy_constructible<T>::value;
  151       std::is_move_constructible<detail::trivial_helper<T>>::value;
  153       !std::is_move_constructible<T>::value;
  157       is_copy_assignable<detail::trivial_helper<T>>::value;
  159       !is_copy_assignable<T>::value;
  163       is_move_assignable<detail::trivial_helper<T>>::value;
  165       !is_move_assignable<T>::value;
  169       std::is_destructible<detail::trivial_helper<T>>::value;

tools/lldb/include/lldb/API/SBType.h

  229   SBType(const lldb_private::CompilerType &);

tools/lldb/include/lldb/Breakpoint/Watchpoint.h

   61              const CompilerType *type, bool hardware = true);
  159   const CompilerType &GetCompilerType() { return m_type; }
  196   CompilerType m_type;

tools/lldb/include/lldb/Core/Value.h

  134   const CompilerType &GetCompilerType();
  136   void SetCompilerType(const CompilerType &compiler_type);
  229   CompilerType m_compiler_type;

tools/lldb/include/lldb/Core/ValueObject.h

  354   CompilerType GetCompilerType();
  376   GetTypeInfo(CompilerType *pointee_or_element_compiler_type = nullptr);
  567   GetSyntheticChildAtOffset(uint32_t offset, const CompilerType &type,
  572   GetSyntheticBase(uint32_t offset, const CompilerType &type, bool can_create,
  610   virtual lldb::ValueObjectSP Cast(const CompilerType &compiler_type);
  613                                               CompilerType &ast_type);
  654                                CompilerType type);
  658                             const ExecutionContext &exe_ctx, CompilerType type);
  863   CompilerType m_override_type; // If the type of the value object should be
  977   virtual CompilerType GetCompilerTypeImpl() = 0;
  987   virtual CompilerType MaybeCalculateCompleteType();

tools/lldb/include/lldb/Core/ValueObjectCast.h

   31                                     const CompilerType &cast_type);
   51                   const CompilerType &cast_type);
   55   CompilerType GetCompilerTypeImpl() override;
   57   CompilerType m_cast_type;

tools/lldb/include/lldb/Core/ValueObjectChild.h

   62   CompilerType GetCompilerTypeImpl() override { return m_compiler_type; }
   64   CompilerType m_compiler_type;
   83   ValueObjectChild(ValueObject &parent, const CompilerType &compiler_type,

tools/lldb/include/lldb/Core/ValueObjectConstResult.h

   42   Create(ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
   47   Create(ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
   53   Create(ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
   85       uint32_t offset, const CompilerType &type, bool can_create,
  108   lldb::ValueObjectSP Cast(const CompilerType &compiler_type) override;
  113   CompilerType GetCompilerTypeImpl() override;
  128                          const CompilerType &compiler_type,
  133                          const CompilerType &compiler_type,
  140                          const CompilerType &compiler_type,

tools/lldb/include/lldb/Core/ValueObjectConstResultCast.h

   31                              const CompilerType &cast_type,
   41   virtual CompilerType GetCompilerType() {
   46       uint32_t offset, const CompilerType &type, bool can_create,
   54   lldb::ValueObjectSP Cast(const CompilerType &compiler_type) override;

tools/lldb/include/lldb/Core/ValueObjectConstResultChild.h

   32                               const CompilerType &compiler_type,
   47   virtual CompilerType GetCompilerType() {
   52       uint32_t offset, const CompilerType &type, bool can_create,
   63   lldb::ValueObjectSP Cast(const CompilerType &compiler_type) override;

tools/lldb/include/lldb/Core/ValueObjectConstResultImpl.h

   45   GetSyntheticChildAtOffset(uint32_t offset, const CompilerType &type,
   53   lldb::ValueObjectSP Cast(const CompilerType &compiler_type);

tools/lldb/include/lldb/Core/ValueObjectDynamicValue.h

  117   CompilerType GetCompilerTypeImpl() override;

tools/lldb/include/lldb/Core/ValueObjectMemory.h

   41                                     const CompilerType &ast_type);
   60   CompilerType GetCompilerTypeImpl() override;
   64   CompilerType m_compiler_type;
   71                     const Address &address, const CompilerType &ast_type);

tools/lldb/include/lldb/Core/ValueObjectRegister.h

   57   CompilerType GetCompilerTypeImpl() override;
   99   CompilerType GetCompilerTypeImpl() override;
  147   CompilerType GetCompilerTypeImpl() override;
  153   CompilerType m_compiler_type;

tools/lldb/include/lldb/Core/ValueObjectSyntheticFilter.h

  129   CompilerType GetCompilerTypeImpl() override;

tools/lldb/include/lldb/Core/ValueObjectVariable.h

   71   CompilerType GetCompilerTypeImpl() override;

tools/lldb/include/lldb/DataFormatters/FormatClasses.h

  129   TypeNameSpecifierImpl(CompilerType type) : m_is_regex(false), m_type() {
  142   CompilerType GetCompilerType() {
  155     CompilerType m_compiler_type;

tools/lldb/include/lldb/DataFormatters/FormatManager.h

  205                                  CompilerType compiler_type, uint32_t reason,

tools/lldb/include/lldb/DataFormatters/FormattersContainer.h

  187     CompilerType ast_type(valobj.GetCompilerType());

tools/lldb/include/lldb/DataFormatters/TypeFormat.h

  210   mutable std::unordered_map<void *, CompilerType> m_types;

tools/lldb/include/lldb/DataFormatters/TypeSynthetic.h

   90                                CompilerType type);
   95                                                 CompilerType type);

tools/lldb/include/lldb/DataFormatters/ValueObjectPrinter.h

  133   CompilerType m_compiler_type;

tools/lldb/include/lldb/Expression/ExpressionVariable.h

   54   CompilerType GetCompilerType() { return m_frozen_sp->GetCompilerType(); }
   56   void SetCompilerType(const CompilerType &compiler_type) {
  221                            ConstString name, const CompilerType &type,
  235   virtual llvm::Optional<CompilerType>

tools/lldb/include/lldb/Expression/FunctionCaller.h

   83                  const CompilerType &return_type,
  317   CompilerType m_function_return_type; ///< The opaque clang qual type for the

tools/lldb/include/lldb/Expression/Materializer.h

   83   uint32_t AddResultVariable(const CompilerType &type, bool is_lvalue,

tools/lldb/include/lldb/Expression/UtilityFunction.h

  100   FunctionCaller *MakeFunctionCaller(const CompilerType &return_type,

tools/lldb/include/lldb/Symbol/ClangASTContext.h

  148   CompilerType GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding,
  151   static CompilerType GetBuiltinTypeForEncodingAndBitSize(
  154   CompilerType GetBasicType(lldb::BasicType type);
  156   static CompilerType GetBasicType(clang::ASTContext *ast,
  159   static CompilerType GetBasicType(clang::ASTContext *ast,
  164   CompilerType GetBuiltinTypeForDWARFEncodingAndBitSize(const char *type_name,
  168   CompilerType GetCStringType(bool is_const);
  170   static CompilerType GetUnknownAnyType(clang::ASTContext *ast);
  172   CompilerType GetUnknownAnyType() {
  178   static clang::DeclContext *GetDeclContextForType(const CompilerType &type);
  192   static bool AreTypesSame(CompilerType type1, CompilerType type2,
  192   static bool AreTypesSame(CompilerType type1, CompilerType type2,
  195   static CompilerType GetTypeForDecl(clang::NamedDecl *decl);
  197   static CompilerType GetTypeForDecl(clang::TagDecl *decl);
  199   static CompilerType GetTypeForDecl(clang::ObjCInterfaceDecl *objc_decl);
  202   CompilerType
  205     CompilerType compiler_type;
  235   CompilerType CreateStructForIdentifier(
  237       const std::initializer_list<std::pair<const char *, CompilerType>>
  241   CompilerType GetOrCreateStructForIdentifier(
  243       const std::initializer_list<std::pair<const char *, CompilerType>>
  261   CompilerType CreateRecordType(clang::DeclContext *decl_ctx,
  306   CompilerType
  327   CompilerType CreateObjCClass(const char *name, clang::DeclContext *decl_ctx,
  356                             const CompilerType &function_Type, int storage,
  359   static CompilerType CreateFunctionType(clang::ASTContext *ast,
  360                                          const CompilerType &result_type,
  361                                          const CompilerType *args,
  366   static CompilerType CreateFunctionType(clang::ASTContext *ast,
  367                                          const CompilerType &result_type,
  368                                          const CompilerType *args,
  375   CompilerType CreateFunctionType(const CompilerType &result_type,
  375   CompilerType CreateFunctionType(const CompilerType &result_type,
  376                                   const CompilerType *args, unsigned num_args,
  382   CompilerType CreateFunctionType(const CompilerType &result_type,
  382   CompilerType CreateFunctionType(const CompilerType &result_type,
  383                                   const CompilerType *args, unsigned num_args,
  393                                                  const CompilerType &param_type,
  400   CompilerType CreateBlockPointerType(const CompilerType &function_type);
  400   CompilerType CreateBlockPointerType(const CompilerType &function_type);
  404   CompilerType CreateArrayType(const CompilerType &element_type,
  404   CompilerType CreateArrayType(const CompilerType &element_type,
  408   CompilerType CreateEnumerationType(const char *name,
  411                                      const CompilerType &integer_qual_type,
  416   static CompilerType GetIntTypeFromBitSize(clang::ASTContext *ast,
  419   CompilerType GetPointerSizedIntType(bool is_signed) {
  423   static CompilerType GetPointerSizedIntType(clang::ASTContext *ast,
  428   static CompilerType GetFloatTypeFromBitSize(clang::ASTContext *ast,
  457   CompilerType DeclGetFunctionReturnType(void *opaque_decl) override;
  461   CompilerType DeclGetFunctionArgumentType(void *opaque_decl,
  464   CompilerType GetTypeForDecl(void *opaque_decl) override;
  512                    CompilerType *element_type, uint64_t *size,
  516                     CompilerType *element_type, uint64_t *size) override;
  533   static bool IsCXXClassType(const CompilerType &type);
  544                                   CompilerType *base_type_ptr) override;
  549   CompilerType GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
  555                           CompilerType *function_pointer_type_ptr) override;
  563   static bool IsObjCClassType(const CompilerType &type);
  565   static bool IsObjCClassTypeAndHasIVars(const CompilerType &type,
  568   static bool IsObjCObjectOrInterfaceType(const CompilerType &type);
  570   static bool IsObjCObjectPointerType(const CompilerType &type,
  571                                       CompilerType *target_type = nullptr);
  580                              CompilerType *target_type, // Can pass nullptr
  586                      CompilerType *pointee_type) override;
  589                                 CompilerType *pointee_type) override;
  592                        CompilerType *pointee_type, bool *is_rvalue) override;
  600   bool CanPassInRegisters(const CompilerType &type) override;
  604   static bool GetCXXClassName(const CompilerType &type,
  616                        CompilerType *pointee_or_element_compiler_type) override;
  629   static CompilerType
  630   CreateTypedefType(const CompilerType &type, const char *typedef_name,
  633   CompilerType GetArrayElementType(lldb::opaque_compiler_type_t type,
  636   CompilerType GetArrayType(lldb::opaque_compiler_type_t type,
  639   CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type) override;
  641   CompilerType
  648   CompilerType GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type,
  651   CompilerType
  660   CompilerType GetNonReferenceType(lldb::opaque_compiler_type_t type) override;
  662   CompilerType GetPointeeType(lldb::opaque_compiler_type_t type) override;
  664   CompilerType GetPointerType(lldb::opaque_compiler_type_t type) override;
  666   CompilerType
  669   CompilerType
  672   CompilerType AddConstModifier(lldb::opaque_compiler_type_t type) override;
  674   CompilerType AddVolatileModifier(lldb::opaque_compiler_type_t type) override;
  676   CompilerType AddRestrictModifier(lldb::opaque_compiler_type_t type) override;
  678   CompilerType CreateTypedef(lldb::opaque_compiler_type_t type,
  683   CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) override;
  686   CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) override;
  716   CompilerType GetBuiltinTypeByName(ConstString name) override;
  727       std::function<bool(const CompilerType &integer_type,
  733   CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx,
  742   CompilerType GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type,
  746   CompilerType GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type,
  752   CompilerType GetChildCompilerTypeAtIndex(
  783   CompilerType GetTypeTemplateArgument(lldb::opaque_compiler_type_t type,
  785   llvm::Optional<CompilerType::IntegralTemplateArgument>
  789   CompilerType GetTypeForFormatters(void *type) override;
  797                            CompilerType *child_type = nullptr);
  800   static clang::FieldDecl *AddFieldToRecordType(const CompilerType &type,
  802                                                 const CompilerType &field_type,
  806   static void BuildIndirectFields(const CompilerType &type);
  808   static void SetIsPacked(const CompilerType &type);
  810   static clang::VarDecl *AddVariableToRecordType(const CompilerType &type,
  812                                                  const CompilerType &var_type,
  818                            const CompilerType &method_type,
  835   static bool SetObjCSuperClass(const CompilerType &type,
  836                                 const CompilerType &superclass_compiler_type);
  838   static bool AddObjCClassProperty(const CompilerType &type,
  840                                    const CompilerType &property_compiler_type,
  848       const CompilerType &type,
  852       const CompilerType &method_compiler_type, lldb::AccessType access,
  859   static bool StartTagDeclarationDefinition(const CompilerType &type);
  861   static bool CompleteTagDeclarationDefinition(const CompilerType &type);
  865       const CompilerType &enum_type, const Declaration &decl, const char *name,
  868       const CompilerType &enum_type, const Declaration &decl, const char *name,
  871   CompilerType GetEnumerationIntegerType(lldb::opaque_compiler_type_t type);
  877   static CompilerType CreateMemberPointerType(const CompilerType &type,
  877   static CompilerType CreateMemberPointerType(const CompilerType &type,
  878                                               const CompilerType &pointee_type);
  921   static void DumpTypeName(const CompilerType &type);
  923   static clang::EnumDecl *GetAsEnumDecl(const CompilerType &type);
  925   static clang::RecordDecl *GetAsRecordDecl(const CompilerType &type);
  927   static clang::TagDecl *GetAsTagDecl(const CompilerType &type);
  929   static clang::TypedefNameDecl *GetAsTypedefDecl(const CompilerType &type);
  934   GetAsObjCInterfaceDecl(const CompilerType &type);
  971   GetDeclarationName(const char *name, const CompilerType &function_clang_type);
 1030   FunctionCaller *GetFunctionCaller(const CompilerType &return_type,

tools/lldb/include/lldb/Symbol/ClangASTImporter.h

  109   CompilerType CopyType(ClangASTContext &dst, const CompilerType &src_type);
  109   CompilerType CopyType(ClangASTContext &dst, const CompilerType &src_type);
  132   bool CanImport(const CompilerType &type);
  134   bool Import(const CompilerType &type);
  136   bool CompleteType(const CompilerType &compiler_type);

tools/lldb/include/lldb/Symbol/ClangUtil.h

   24   static bool IsClangType(const CompilerType &ct);
   26   static clang::QualType GetQualType(const CompilerType &ct);
   28   static clang::QualType GetCanonicalQualType(const CompilerType &ct);
   30   static CompilerType RemoveFastQualifiers(const CompilerType &ct);
   30   static CompilerType RemoveFastQualifiers(const CompilerType &ct);
   32   static clang::TagDecl *GetAsTagDecl(const CompilerType &type);

tools/lldb/include/lldb/Symbol/CompilerDecl.h

   67   CompilerType GetFunctionReturnType() const;
   75   CompilerType GetFunctionArgumentType(size_t arg_idx) const;

tools/lldb/include/lldb/Symbol/CompilerType.h

   35   CompilerType(const CompilerType &rhs)
   44   const CompilerType &operator=(const CompilerType &rhs) {
   44   const CompilerType &operator=(const CompilerType &rhs) {
   56   bool operator<(const CompilerType &rhs) const {
   64   bool IsArrayType(CompilerType *element_type, uint64_t *size,
   67   bool IsVectorType(CompilerType *element_type, uint64_t *size) const;
   91   uint32_t IsHomogeneousAggregate(CompilerType *base_type_ptr) const;
   95   CompilerType GetFunctionArgumentAtIndex(const size_t index) const;
  101   bool IsBlockPointerType(CompilerType *function_pointer_type_ptr) const;
  112   IsPossibleCPlusPlusDynamicType(CompilerType *target_type = nullptr) const {
  116   bool IsPossibleDynamicType(CompilerType *target_type, // Can pass nullptr
  123   bool IsPointerType(CompilerType *pointee_type = nullptr) const;
  125   bool IsPointerOrReferenceType(CompilerType *pointee_type = nullptr) const;
  127   bool IsReferenceType(CompilerType *pointee_type = nullptr,
  159   GetTypeInfo(CompilerType *pointee_or_element_compiler_type = nullptr) const;
  174   CompilerType GetArrayElementType(uint64_t *stride = nullptr) const;
  176   CompilerType GetArrayType(uint64_t size) const;
  178   CompilerType GetCanonicalType() const;
  180   CompilerType GetFullyUnqualifiedType() const;
  186   CompilerType GetFunctionArgumentTypeAtIndex(size_t idx) const;
  188   CompilerType GetFunctionReturnType() const;
  197   CompilerType GetNonReferenceType() const;
  201   CompilerType GetPointeeType() const;
  204   CompilerType GetPointerType() const;
  209   CompilerType GetLValueReferenceType() const;
  214   CompilerType GetRValueReferenceType() const;
  219   CompilerType AddConstModifier() const;
  224   CompilerType AddVolatileModifier() const;
  229   CompilerType AddRestrictModifier() const;
  234   CompilerType CreateTypedef(const char *name,
  238   CompilerType GetTypedefedType() const;
  241   CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) const;
  269       std::function<bool(const CompilerType &integer_type,
  275   CompilerType GetFieldAtIndex(size_t idx, std::string &name,
  284   CompilerType GetDirectBaseClassAtIndex(size_t idx,
  287   CompilerType GetVirtualBaseClassAtIndex(size_t idx,
  291                                    CompilerType *field_compiler_type = nullptr,
  296   CompilerType GetChildCompilerTypeAtIndex(
  323   CompilerType GetTypeTemplateArgument(size_t idx) const;
  329   CompilerType GetTypeForFormatters() const;
  383 bool operator==(const CompilerType &lhs, const CompilerType &rhs);
  383 bool operator==(const CompilerType &lhs, const CompilerType &rhs);
  384 bool operator!=(const CompilerType &lhs, const CompilerType &rhs);
  384 bool operator!=(const CompilerType &lhs, const CompilerType &rhs);
  388   CompilerType type;

tools/lldb/include/lldb/Symbol/DeclVendor.h

   66   std::vector<CompilerType> FindTypes(ConstString name, uint32_t max_matches);

tools/lldb/include/lldb/Symbol/Function.h

  492   CompilerType GetCompilerType();

tools/lldb/include/lldb/Symbol/SymbolFile.h

  156   virtual bool CompleteType(CompilerType &compiler_type) = 0;

tools/lldb/include/lldb/Symbol/TaggedASTType.h

   18 template <unsigned int C> class TaggedASTType : public CompilerType {
   20   TaggedASTType(const CompilerType &compiler_type)

tools/lldb/include/lldb/Symbol/Type.h

  103        const Declaration &decl, const CompilerType &compiler_qual_type,
  180   CompilerType GetFullCompilerType();
  185   CompilerType GetLayoutCompilerType();
  189   CompilerType GetForwardCompilerType();
  220   CompilerType m_compiler_type;
  248   TypeImpl(const CompilerType &compiler_type);
  250   TypeImpl(const lldb::TypeSP &type_sp, const CompilerType &dynamic);
  252   TypeImpl(const CompilerType &compiler_type, const CompilerType &dynamic);
  252   TypeImpl(const CompilerType &compiler_type, const CompilerType &dynamic);
  256   void SetType(const CompilerType &compiler_type);
  258   void SetType(const lldb::TypeSP &type_sp, const CompilerType &dynamic);
  260   void SetType(const CompilerType &compiler_type, const CompilerType &dynamic);
  260   void SetType(const CompilerType &compiler_type, const CompilerType &dynamic);
  290   CompilerType GetCompilerType(bool prefer_dynamic);
  301   CompilerType m_static_type;
  302   CompilerType m_dynamic_type;
  395   TypeAndOrName(const CompilerType &compiler_type);
  405   CompilerType GetCompilerType() const { return m_compiler_type; }
  413   void SetCompilerType(CompilerType compiler_type);
  428   CompilerType m_compiler_type;
  438   TypeMemberFunctionImpl(const CompilerType &type, const CompilerDecl &decl,
  449   CompilerType GetType() const;
  451   CompilerType GetReturnType() const;
  455   CompilerType GetArgumentAtIndex(size_t idx) const;
  465   CompilerType m_type;

tools/lldb/include/lldb/Symbol/TypeSystem.h

  123   virtual CompilerType DeclGetFunctionReturnType(void *opaque_decl);
  127   virtual CompilerType DeclGetFunctionArgumentType(void *opaque_decl,
  130   virtual CompilerType GetTypeForDecl(void *opaque_decl) = 0;
  155                            CompilerType *element_type, uint64_t *size,
  177   virtual CompilerType
  184                                   CompilerType *function_pointer_type_ptr) = 0;
  196                                      CompilerType *target_type, // Can pass NULL
  200                              CompilerType *pointee_type) = 0;
  206   virtual bool CanPassInRegisters(const CompilerType &type) = 0;
  225               CompilerType *pointee_or_element_compiler_type) = 0;
  234   virtual CompilerType GetArrayElementType(lldb::opaque_compiler_type_t type,
  237   virtual CompilerType GetArrayType(lldb::opaque_compiler_type_t type,
  240   virtual CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type) = 0;
  246   virtual CompilerType
  250   virtual CompilerType
  258   virtual CompilerType GetPointeeType(lldb::opaque_compiler_type_t type) = 0;
  260   virtual CompilerType GetPointerType(lldb::opaque_compiler_type_t type) = 0;
  262   virtual CompilerType
  265   virtual CompilerType
  268   virtual CompilerType AddConstModifier(lldb::opaque_compiler_type_t type);
  270   virtual CompilerType AddVolatileModifier(lldb::opaque_compiler_type_t type);
  272   virtual CompilerType AddRestrictModifier(lldb::opaque_compiler_type_t type);
  274   virtual CompilerType CreateTypedef(lldb::opaque_compiler_type_t type,
  295   virtual CompilerType GetBuiltinTypeByName(ConstString name);
  302       std::function<bool(const CompilerType &integer_type,
  308   virtual CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type,
  320   virtual CompilerType
  324   virtual CompilerType
  328   virtual CompilerType GetChildCompilerTypeAtIndex(
  358   virtual CompilerType GetTypeTemplateArgument(lldb::opaque_compiler_type_t type,
  360   virtual llvm::Optional<CompilerType::IntegralTemplateArgument>
  405                                         CompilerType *pointee_type) = 0;
  416   virtual CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) = 0;
  418   virtual CompilerType
  427                                           CompilerType *base_type_ptr) = 0;
  434   virtual CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) = 0;
  437                             CompilerType *element_type, uint64_t *size) = 0;
  439   virtual CompilerType
  442   virtual CompilerType
  446                                CompilerType *pointee_type, bool *is_rvalue) = 0;
  462   virtual FunctionCaller *GetFunctionCaller(const CompilerType &return_type,
  478   virtual CompilerType GetTypeForFormatters(void *type);

tools/lldb/include/lldb/Target/ABI.h

   67   lldb::ValueObjectSP GetReturnValueObject(Thread &thread, CompilerType &type,
   83   GetReturnValueObjectImpl(Thread &thread, CompilerType &ast_type) const = 0;

tools/lldb/include/lldb/Target/Language.h

   60       Result(CompilerType type)
   77       CompilerType m_compiler_type;
   89     virtual CompilerType AdjustForInclusion(CompilerType &candidate) = 0;
   89     virtual CompilerType AdjustForInclusion(CompilerType &candidate) = 0;

tools/lldb/include/lldb/Target/LanguageRuntime.h

   87   virtual CompilerType GetConcreteType(ExecutionContextScope *exe_scope,
  145   virtual bool GetTypeBitSize(const CompilerType &compiler_type,
  159   virtual llvm::Optional<CompilerType> GetRuntimeType(CompilerType base_type) {
  159   virtual llvm::Optional<CompilerType> GetRuntimeType(CompilerType base_type) {

tools/lldb/include/lldb/Target/ProcessStructReader.h

   30     CompilerType type;
   42                       CompilerType struct_type) {
   55       CompilerType field_type = struct_type.GetFieldAtIndex(

tools/lldb/include/lldb/Target/StackFrameRecognizer.h

  150   CompilerType GetCompilerTypeImpl() override {

tools/lldb/include/lldb/Target/Target.h

  683                                       const CompilerType *type, uint32_t kind,
 1056                                                const CompilerType &return_type,

tools/lldb/include/lldb/Target/ThreadPlanCallFunction.h

   26                          const CompilerType &return_type,
  148   CompilerType m_return_type;

tools/lldb/source/API/SBModule.cpp

  514         CompilerType compiler_type =

tools/lldb/source/API/SBTarget.cpp

 1427     CompilerType *type = nullptr;
 1477     CompilerType ast_type(type.GetSP()->GetCompilerType(true));
 1497     CompilerType ast_type(type.GetSP()->GetCompilerType(true));
 1857       if (auto type = type_system->GetBuiltinTypeByName(const_typename))
 1871       if (auto compiler_type = type_system->GetBasicTypeFromAST(type))
 1904           for (auto type : types)
 1913         if (auto compiler_type =

tools/lldb/source/API/SBType.cpp

   30 SBType::SBType(const CompilerType &type)
  233     CompilerType vector_element_type;
  277     CompilerType return_type(
  291     CompilerType func_type(m_opaque_sp->GetCompilerType(true));
  403     CompilerType base_class_type =
  420     CompilerType base_class_type =
  436     CompilerType this_type(m_opaque_sp->GetCompilerType(true));
  459     CompilerType this_type(m_opaque_sp->GetCompilerType(false));
  465       CompilerType field_type(this_type.GetFieldAtIndex(
  535   CompilerType type;

tools/lldb/source/API/SBTypeNameSpecifier.cpp

   74   lldb_private::CompilerType c_type = m_opaque_sp->GetCompilerType();

tools/lldb/source/API/SBValue.cpp

  661     CompilerType ast_type(type_impl_sp->GetCompilerType(true));
 1502     CompilerType type(value_sp->GetCompilerType());

tools/lldb/source/Breakpoint/Watchpoint.cpp

   27                        const CompilerType *type, bool hardware)

tools/lldb/source/Commands/CommandObjectExpression.cpp

  359   CompilerType type(valobj.GetCompilerType());
  360   CompilerType pointee;

tools/lldb/source/Commands/CommandObjectMemory.cpp

  371     CompilerType compiler_type;
  481         std::set<CompilerType> user_defined_types;
  485             if (llvm::Optional<CompilerType> type =
  522         CompilerType pointer_type = compiler_type.GetPointerType();
  897   CompilerType m_prev_compiler_type;

tools/lldb/source/Commands/CommandObjectWatchpoint.cpp

  856     CompilerType compiler_type;
 1055     CompilerType compiler_type(valobj_sp->GetCompilerType());

tools/lldb/source/Core/Value.cpp

  239 const CompilerType &Value::GetCompilerType() {
  268 void Value::SetCompilerType(const CompilerType &compiler_type) {
  282     const CompilerType &ast_type = GetCompilerType();
  324   const CompilerType &ast_type = GetCompilerType();
  585   const CompilerType &compiler_type = GetCompilerType();

tools/lldb/source/Core/ValueObject.cpp

  324 CompilerType ValueObject::MaybeCalculateCompleteType() {
  325   CompilerType compiler_type(GetCompilerTypeImpl());
  344     if (llvm::Optional<CompilerType> complete_type =
  354 CompilerType ValueObject::GetCompilerType() {
  656   CompilerType child_compiler_type;
  745   CompilerType pointee_or_element_compiler_type;
  763   CompilerType pointee_or_element_compiler_type;
  975   CompilerType compiler_type = GetCompilerType();
  976   CompilerType elem_or_pointee_compiler_type;
 1688 ValueObject::GetTypeInfo(CompilerType *pointee_or_element_compiler_type) {
 1821     uint32_t offset, const CompilerType &type, bool can_create,
 1860                                             const CompilerType &type,
 2025     CompilerType compiler_type = GetCompilerType();
 2127         CompilerType non_base_class_parent_compiler_type =
 2247     CompilerType root_compiler_type = root->GetCompilerType();
 2248     CompilerType pointee_compiler_type;
 2841     CompilerType compiler_type = GetCompilerType();
 2842     CompilerType child_compiler_type;
 2908       CompilerType compiler_type = GetCompilerType();
 2932 ValueObjectSP ValueObject::Cast(const CompilerType &compiler_type) {
 2941                                            CompilerType &compiler_type) {
 3159     CompilerType type) {
 3161     CompilerType pointer_type(type.GetPointerType());
 3185     const ExecutionContext &exe_ctx, CompilerType type) {
 3283   const CompilerType &type(GetCompilerType());

tools/lldb/source/Core/ValueObjectCast.cpp

   26                                             const CompilerType &cast_type) {
   33                                  const CompilerType &cast_type)
   43 CompilerType ValueObjectCast::GetCompilerTypeImpl() { return m_cast_type; }
   70     CompilerType compiler_type(GetCompilerType());

tools/lldb/source/Core/ValueObjectChild.cpp

   30     ValueObject &parent, const CompilerType &compiler_type,
  118       CompilerType parent_type(parent->GetCompilerType());

tools/lldb/source/Core/ValueObjectConstResult.cpp

   51                                              const CompilerType &compiler_type,
   61     ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
   83                                              const CompilerType &compiler_type,
  102     ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
  122                                              const CompilerType &compiler_type,
  133     ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
  190 CompilerType ValueObjectConstResult::GetCompilerTypeImpl() {
  243     uint32_t offset, const CompilerType &type, bool can_create,
  288 ValueObjectConstResult::Cast(const CompilerType &compiler_type) {

tools/lldb/source/Core/ValueObjectConstResultCast.cpp

   24     ValueObject &parent, ConstString name, const CompilerType &cast_type,
   37     uint32_t offset, const CompilerType &type, bool can_create,
   60 ValueObjectConstResultCast::Cast(const CompilerType &compiler_type) {

tools/lldb/source/Core/ValueObjectConstResultChild.cpp

   25     ValueObject &parent, const CompilerType &compiler_type,
   44     uint32_t offset, const CompilerType &type, bool can_create,
   72 ValueObjectConstResultChild::Cast(const CompilerType &compiler_type) {

tools/lldb/source/Core/ValueObjectConstResultImpl.cpp

   69   CompilerType compiler_type = m_impl_backend->GetCompilerType();
   70   CompilerType child_compiler_type;
  107     uint32_t offset, const CompilerType &type, bool can_create,
  123     CompilerType compiler_type(m_impl_backend->GetCompilerType());
  145 ValueObjectConstResultImpl::Cast(const CompilerType &compiler_type) {

tools/lldb/source/Core/ValueObjectDynamicValue.cpp

   43 CompilerType ValueObjectDynamicValue::GetCompilerTypeImpl() {

tools/lldb/source/Core/ValueObjectMemory.cpp

   41                                         const CompilerType &ast_type) {
   75                                      const CompilerType &ast_type)
  106 CompilerType ValueObjectMemory::GetCompilerTypeImpl() {

tools/lldb/source/Core/ValueObjectRegister.cpp

   50 CompilerType ValueObjectRegisterContext::GetCompilerTypeImpl() {
  127 CompilerType ValueObjectRegisterSet::GetCompilerTypeImpl() {
  257 CompilerType ValueObjectRegister::GetCompilerTypeImpl() {

tools/lldb/source/Core/ValueObjectSyntheticFilter.cpp

   62 CompilerType ValueObjectSynthetic::GetCompilerTypeImpl() {
  132     CompilerType type = m_parent->GetCompilerType();

tools/lldb/source/Core/ValueObjectVariable.cpp

   66 CompilerType ValueObjectVariable::GetCompilerTypeImpl() {
   95   CompilerType type(GetCompilerType());
  109   CompilerType type(GetCompilerType());
  163       CompilerType compiler_type = GetCompilerType();

tools/lldb/source/DataFormatters/FormatManager.cpp

  177     ValueObject &valobj, CompilerType compiler_type, uint32_t reason,
  204     CompilerType non_ref_type = compiler_type.GetNonReferenceType();
  211       CompilerType deffed_referenced_type = non_ref_type.GetTypedefedType();
  224     CompilerType non_ptr_type = compiler_type.GetPointeeType();
  231       CompilerType deffed_pointed_type =
  255     CompilerType deffed_type = compiler_type.GetTypedefedType();
  267       CompilerType unqual_compiler_ast_type =
  484   CompilerType compiler_type(valobj.GetCompilerType());
  506     CompilerType child_compiler_type(child_sp->GetCompilerType());

tools/lldb/source/DataFormatters/TypeFormat.cpp

   66       CompilerType compiler_type = value.GetCompilerType();
  157   CompilerType valobj_enum_type;

tools/lldb/source/DataFormatters/TypeSynthetic.cpp

  110     CompilerType type) {
  120     const ExecutionContext &exe_ctx, CompilerType type) {

tools/lldb/source/DataFormatters/ValueObjectPrinter.cpp

  343 static bool IsPointerValue(const CompilerType &type) {

tools/lldb/source/DataFormatters/VectorType.cpp

   24 static CompilerType GetCompilerTypeForFormat(lldb::Format format,
   25                                              CompilerType element_type,
  123                                            CompilerType element_type) {
  170     CompilerType container_type, CompilerType element_type,
  170     CompilerType container_type, CompilerType element_type,
  220     CompilerType parent_type(m_backend.GetCompilerType());
  221     CompilerType element_type;
  255   CompilerType m_child_type;

tools/lldb/source/Expression/FunctionCaller.cpp

   34                                const CompilerType &return_type,

tools/lldb/source/Expression/Materializer.cpp

  763   EntityResultVariable(const CompilerType &type, bool is_program_reference,
 1020   CompilerType m_type;
 1029 uint32_t Materializer::AddResultVariable(const CompilerType &type,

tools/lldb/source/Expression/UtilityFunction.cpp

   62     const CompilerType &return_type, const ValueList &arg_value_list,

tools/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp

 1467     CompilerType compiler_type = value->GetCompilerType();
 1557     Thread &thread, lldb_private::CompilerType &compiler_type) const {
 1708   CompilerType compiler_type = new_value_sp->GetCompilerType();

tools/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h

   85                            lldb_private::CompilerType &ast_type) const override;

tools/lldb/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp

 1762     CompilerType value_type = value->GetCompilerType();
 1865   CompilerType return_value_type = new_value_sp->GetCompilerType();
 2108     const CompilerType &value_type,
 2122   CompilerType base_type;
 2251     Thread &thread, CompilerType &return_compiler_type) const {

tools/lldb/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.h

   93                            lldb_private::CompilerType &ast_type) const override;

tools/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp

  824     CompilerType compiler_type(value->GetCompilerType());
  848   CompilerType compiler_type = new_value_sp->GetCompilerType();
  916                                          CompilerType &compiler_type) const {

tools/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h

   90                            lldb_private::CompilerType &ast_type) const override;

tools/lldb/source/Plugins/ABI/SysV-arc/ABISysV_arc.cpp

  317   CompilerType compiler_type = new_value_sp->GetCompilerType();
  445                                         CompilerType &compiler_type) const {
  499     Thread &thread, CompilerType &return_compiler_type) const {

tools/lldb/source/Plugins/ABI/SysV-arc/ABISysV_arc.h

   46                            lldb_private::CompilerType &type) const override;
   96                              lldb_private::CompilerType &ast_type) const;

tools/lldb/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp

 1468     CompilerType compiler_type = value->GetCompilerType();
 1554     Thread &thread, lldb_private::CompilerType &compiler_type) const {
 1713       CompilerType base_type;
 1851   CompilerType compiler_type = new_value_sp->GetCompilerType();

tools/lldb/source/Plugins/ABI/SysV-arm/ABISysV_arm.h

   85                            lldb_private::CompilerType &ast_type) const override;

tools/lldb/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp

 1764     CompilerType value_type = value->GetCompilerType();
 1837   CompilerType return_value_type = new_value_sp->GetCompilerType();
 2084     const CompilerType &value_type,
 2099   CompilerType base_type;
 2221     Thread &thread, CompilerType &return_compiler_type) const {

tools/lldb/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.h

   92                            lldb_private::CompilerType &ast_type) const override;

tools/lldb/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp

 1197     Thread &thread, CompilerType &return_compiler_type) const {
 1203     Thread &thread, CompilerType &return_compiler_type) const {

tools/lldb/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.h

   43                            lldb_private::CompilerType &type) const override;
   95                              lldb_private::CompilerType &ast_type) const;

tools/lldb/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp

  308     CompilerType compiler_type(value->GetCompilerType());
  332   CompilerType compiler_type = new_value_sp->GetCompilerType();
  477     Thread &thread, CompilerType &return_compiler_type) const {
  713     Thread &thread, CompilerType &return_compiler_type) const {

tools/lldb/source/Plugins/ABI/SysV-i386/ABISysV_i386.h

   37                            lldb_private::CompilerType &type) const override;
   98                              lldb_private::CompilerType &ast_type) const;

tools/lldb/source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp

  705   CompilerType compiler_type = new_value_sp->GetCompilerType();
  772     Thread &thread, CompilerType &return_compiler_type) const {
  778     Thread &thread, CompilerType &return_compiler_type) const {

tools/lldb/source/Plugins/ABI/SysV-mips/ABISysV_mips.h

   35                            lldb_private::CompilerType &type) const override;
   85                              lldb_private::CompilerType &ast_type) const;

tools/lldb/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp

  666   CompilerType compiler_type = new_value_sp->GetCompilerType();
  729     Thread &thread, CompilerType &return_compiler_type) const {
  735     Thread &thread, CompilerType &return_compiler_type) const {
  935           CompilerType field_compiler_type =
  959             CompilerType field_compiler_type =
 1032         CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex(

tools/lldb/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.h

   35                            lldb_private::CompilerType &type) const override;
   98                              lldb_private::CompilerType &ast_type) const;

tools/lldb/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp

  394     CompilerType compiler_type = value->GetCompilerType();
  420   CompilerType compiler_type = new_value_sp->GetCompilerType();
  505     Thread &thread, CompilerType &return_compiler_type) const {
  644     Thread &thread, CompilerType &return_compiler_type) const {
  701         CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex(
  766                 CompilerType next_field_compiler_type =
  786                 CompilerType prev_field_compiler_type =

tools/lldb/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.h

   35                            lldb_private::CompilerType &type) const override;
   94                              lldb_private::CompilerType &ast_type) const;

tools/lldb/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp

  270     CompilerType compiler_type = value->GetCompilerType();
  298   CompilerType compiler_type = new_value_sp->GetCompilerType();
  498                                                      CompilerType &type) {
  550   CompilerType &m_type;
  565   ReturnValueExtractor(Thread &thread, CompilerType &type,
  575   ValueSP NewScalarValue(CompilerType &type) {
  632   ValueSP GetFloatValue(CompilerType &type, uint32_t reg_index) {
  775     CompilerType elem_type;
  898   CompilerType GetChildType(uint32_t i, std::string &name, uint32_t &size) {
  928                                           CompilerType &type) const {
  944     Thread &thread, CompilerType &return_compiler_type) const {

tools/lldb/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.h

   35                            lldb_private::CompilerType &type) const override;
   94                              lldb_private::CompilerType &ast_type) const;

tools/lldb/source/Plugins/ABI/SysV-s390x/ABISysV_s390x.cpp

  370     CompilerType compiler_type = value->GetCompilerType();
  398   CompilerType compiler_type = new_value_sp->GetCompilerType();
  487     Thread &thread, CompilerType &return_compiler_type) const {
  596     Thread &thread, CompilerType &return_compiler_type) const {

tools/lldb/source/Plugins/ABI/SysV-s390x/ABISysV_s390x.h

   35                            lldb_private::CompilerType &type) const override;
   86                              lldb_private::CompilerType &ast_type) const;

tools/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp

  420     CompilerType compiler_type = value->GetCompilerType();
  448   CompilerType compiler_type = new_value_sp->GetCompilerType();
  538     Thread &thread, CompilerType &return_compiler_type) const {
  726     CompilerType &return_compiler_type,
  729     std::vector<CompilerType> &aggregate_compiler_types) {
  739     CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex(
  769     Thread &thread, CompilerType &return_compiler_type) const {
  791     std::vector<CompilerType> aggregate_compiler_types;
  846         CompilerType field_compiler_type = aggregate_compiler_types[idx];
  906                 CompilerType next_field_compiler_type =
  923                 CompilerType prev_field_compiler_type =

tools/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.h

   35                            lldb_private::CompilerType &type) const override;
   96                              lldb_private::CompilerType &ast_type) const;

tools/lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.cpp

 1253     CompilerType compiler_type = value->GetCompilerType();
 1281   CompilerType compiler_type = new_value_sp->GetCompilerType();
 1374     Thread &thread, CompilerType &return_compiler_type) const {
 1525     CompilerType &return_compiler_type,
 1528     std::vector<CompilerType> &aggregate_compiler_types) {
 1538     CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex(
 1573     Thread &thread, CompilerType &return_compiler_type) const {
 1616   std::vector<CompilerType> aggregate_compiler_types;
 1649       CompilerType field_compiler_type = aggregate_compiler_types[idx];

tools/lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.h

   35                            lldb_private::CompilerType &type) const override;
   89                              lldb_private::CompilerType &ast_type) const;

tools/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

 1081           CompilerType clang_void_ptr_type =

tools/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.cpp

  234     CompilerType clang_void_ptr_type =
  236     CompilerType clang_uint32_type =
  239     CompilerType clang_uint64_type =

tools/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

  349     CompilerType clang_void_ptr_type =
  351     CompilerType clang_uint32_type =

tools/lldb/source/Plugins/ExpressionParser/Clang/ASTDumper.cpp

   72 ASTDumper::ASTDumper(const CompilerType &compiler_type) {

tools/lldb/source/Plugins/ExpressionParser/Clang/ASTDumper.h

   27   ASTDumper(const CompilerType &compiler_type);

tools/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

  345           CompilerType clang_type(type->GetFullCompilerType());
  383         CompilerType clang_type(type->GetFullCompilerType());
  897         CompilerType full_type = type_sp->GetFullCompilerType();
  899         CompilerType copied_clang_type(GuardedCopyType(full_type));
 2051 CompilerType ClangASTSource::GuardedCopyType(const CompilerType &src_type) {
 2051 CompilerType ClangASTSource::GuardedCopyType(const CompilerType &src_type) {
 2088 clang::NamedDecl *NameSearchContext::AddVarDecl(const CompilerType &type) {
 2111 clang::NamedDecl *NameSearchContext::AddFunDecl(const CompilerType &type,
 2219 NameSearchContext::AddTypeDecl(const CompilerType &clang_type) {

tools/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.h

  336   CompilerType GuardedCopyType(const CompilerType &src_type);
  336   CompilerType GuardedCopyType(const CompilerType &src_type);
  445   llvm::SmallSet<CompilerType, 5> m_function_types; ///< All the types of
  487   clang::NamedDecl *AddVarDecl(const CompilerType &type);
  497   clang::NamedDecl *AddFunDecl(const CompilerType &type, bool extern_c = false);
  508   clang::NamedDecl *AddTypeDecl(const CompilerType &compiler_type);

tools/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

 1065           CompilerType self_clang_type = self_type->GetFullCompilerType();
 1267           CompilerType m_copied_type;
 1300           CompilerType func_clang_type =
 1302           CompilerType copied_func_type = GuardedCopyType(func_clang_type);
 1327         std::multimap<CompilerType, const FuncDeclInfo *> matches;
 1329           const CompilerType t = fdi.m_copied_type;
 1529   CompilerType var_clang_type = var_type->GetFullCompilerType();
 1573   CompilerType type_to_use = GuardedCopyType(var_clang_type);
 1851   CompilerType clang_type =
 1900   CompilerType function_clang_type;
 1993     CompilerType copied_function_type = GuardedCopyType(function_clang_type);
 2084   CompilerType copied_clang_type = GuardedCopyType(ut);
 2099     CompilerType void_clang_type =
 2101     CompilerType void_ptr_clang_type = void_clang_type.GetPointerType();
 2103     CompilerType method_type = ClangASTContext::CreateFunctionType(
 2160   CompilerType copied_clang_type = GuardedCopyType(ut);

tools/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.cpp

   47                                          const CompilerType &return_type,
  105   CompilerType function_clang_type;
  132       CompilerType clang_qual_type =

tools/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h

  115                       const CompilerType &return_type,

tools/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.cpp

   35     const CompilerType &compiler_type, lldb::ByteOrder byte_order,
   67 llvm::Optional<CompilerType>
   70   CompilerType compiler_type;

tools/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h

   44       const CompilerType &compiler_type, lldb::ByteOrder byte_order,
   62   llvm::Optional<CompilerType>

tools/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

  285           CompilerType self_clang_type = self_type->GetForwardCompilerType();

tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

 1226     lldb_private::CompilerType compiler_type(

tools/lldb/source/Plugins/Language/CPlusPlus/BlockPointer.cpp

   33     CompilerType block_pointer_type(m_backend.GetCompilerType());
   34     CompilerType function_pointer_type;
   66     const CompilerType isa_type =
   69     const CompilerType flags_type =
   72     const CompilerType reserved_type =
   75     const CompilerType FuncPtr_type =
  118     const CompilerType child_type =
  164   CompilerType m_block_struct_type;

tools/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

  922     CompilerType AdjustForInclusion(CompilerType &candidate) override {
  922     CompilerType AdjustForInclusion(CompilerType &candidate) override {

tools/lldb/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp

  121   CompilerType wchar_compiler_type =
  244   CompilerType wchar_compiler_type =

tools/lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp

  228       CompilerType pair_type(
  248         CompilerType tree_node_type = ast_ctx->CreateStructForIdentifier(

tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxBitset.cpp

   42   CompilerType m_bool_type;
   85   CompilerType type;

tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp

   40   CompilerType m_element_type;

tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxList.cpp

  134   CompilerType m_element_type;
  184   CompilerType list_type = m_backend.GetCompilerType();

tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp

  196   CompilerType m_element_type;
  293   CompilerType node_type(node->GetCompilerType());
  303     CompilerType tree_node_type = ast_ctx->CreateStructForIdentifier(

tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxOptional.cpp

   69   CompilerType holder_type = val_sp->GetCompilerType();

tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxTuple.cpp

   69   CompilerType holder_type =

tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp

   45   CompilerType m_element_type;
   46   CompilerType m_node_type;

tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxVariant.cpp

  152   CompilerType head_type = nth_head->GetCompilerType();
  157   CompilerType template_type = head_type.GetTypeTemplateArgument(1);
  229   CompilerType head_type = nth_head->GetCompilerType();
  234   CompilerType template_type = head_type.GetTypeTemplateArgument(1);

tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp

   40   CompilerType m_element_type;
   59   CompilerType m_bool_type;
  289   CompilerType type = valobj_sp->GetCompilerType();
  292   CompilerType arg_type = type.GetTypeTemplateArgument(0);

tools/lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp

   57   CompilerType m_pair_type;
  113   CompilerType my_type(valobj_sp->GetCompilerType());
  115     CompilerType pair_type = my_type.GetTypeTemplateArgument(0);
  293       CompilerType wchar_compiler_type =

tools/lldb/source/Plugins/Language/ObjC/Cocoa.cpp

  694   CompilerType type(valobj.GetCompilerType());
 1058   CompilerType charstar(valobj.GetCompilerType()

tools/lldb/source/Plugins/Language/ObjC/CoreMedia.cpp

   25   CompilerType type = valobj.GetCompilerType();
   40   auto int64_ty = type_system_or_err->GetBuiltinTypeForEncodingAndBitSize(
   42   auto int32_ty = type_system_or_err->GetBuiltinTypeForEncodingAndBitSize(

tools/lldb/source/Plugins/Language/ObjC/NSArray.cpp

   73   CompilerType m_id_type;
  253   CompilerType m_id_type;
  611     CompilerType type = valobj_sp->GetCompilerType();
  783     CompilerType id_type(
  806   CompilerType valobj_type(valobj_sp->GetCompilerType());

tools/lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

   65 static CompilerType GetLLDBNSPairType(TargetSP target_sp) {
   66   CompilerType compiler_type;
   84         CompilerType id_compiler_type =
  138   CompilerType m_pair_type;
  191   CompilerType m_pair_type;
  242     CompilerType m_pair_type;
  444   CompilerType valobj_type(valobj_sp->GetCompilerType());
  696   auto pair_type =

tools/lldb/source/Plugins/Language/ObjC/NSError.cpp

   32   CompilerType valobj_type(valobj.GetCompilerType());
   40       CompilerType pointee_type(valobj_type.GetPointeeType());

tools/lldb/source/Plugins/Language/ObjC/NSException.cpp

   40   CompilerType valobj_type(valobj.GetCompilerType());
   72   CompilerType voidstar = process_sp->GetTarget()

tools/lldb/source/Plugins/Language/ObjC/NSIndexPath.cpp

  156                                         const CompilerType &desired_type) {
  180                                           const CompilerType &desired_type) {
  298   CompilerType m_uint_star_type;

tools/lldb/source/Plugins/Language/ObjC/NSSet.cpp

  308   CompilerType valobj_type(valobj_sp->GetCompilerType());

tools/lldb/source/Plugins/Language/ObjC/NSString.cpp

   35 static CompilerType GetNSPathStore2Type(Target &target) {
   43   CompilerType voidstar =
   45   CompilerType uint32 =
  308   CompilerType type(valobj.GetCompilerType());

tools/lldb/source/Plugins/Language/ObjC/ObjCLanguage.cpp

  883   CompilerType compiler_type(valobj.GetCompilerType());
  913     ObjCScavengerResult(CompilerType type)
  928     CompilerType m_compiler_type;
  941             for (const CompilerType &type :
  987     CompilerType AdjustForInclusion(CompilerType &candidate) override {
  987     CompilerType AdjustForInclusion(CompilerType &candidate) override {

tools/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

  233   CompilerType type = class_type_or_name.GetCompilerType();
  272   CompilerType static_type(static_value.GetCompilerType());
  281     CompilerType orig_type = type_and_or_name.GetCompilerType();
  282     CompilerType corrected_type = orig_type;
  541   CompilerType voidstar =

tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp

  524     CompilerType ivar_type =

tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.cpp

  507     CompilerType ivar_type = m_runtime.GetEncodingToType()->RealizeType(

tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp

   59   CompilerType compiler_type(valobj.GetCompilerType());
  106   CompilerType compiler_type = value.GetCompilerType();
  115     CompilerType opaque_type = ast_context->GetBasicType(eBasicTypeObjCID);
  128   CompilerType return_compiler_type = ast_context->GetCStringType(true);
  260   CompilerType static_type(static_value.GetCompilerType());
  269     CompilerType orig_type = type_and_or_name.GetCompilerType();
  270     CompilerType corrected_type = orig_type;
  497   CompilerType objc_id =

tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

  896 size_t AppleObjCRuntimeV2::GetByteOffsetForIvar(CompilerType &parent_ast_type,
 1325   CompilerType clang_uint32_t_type =
 1327   CompilerType clang_void_pointer_type =
 1589   CompilerType clang_uint32_t_type =
 1591   CompilerType clang_void_pointer_type =
 2681     CompilerType voidstar = process_sp->GetTarget()

tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h

   67   size_t GetByteOffsetForIvar(CompilerType &parent_qual_type,

tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp

  528     CompilerType clang_void_ptr_type =
  806       CompilerType clang_void_ptr_type =
  901     CompilerType clang_void_ptr_type =
 1074       CompilerType clang_int_type =

tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp

  130   CompilerType union_type(lldb_ctx->CreateRecordType(
  165   CompilerType array_type(lldb_ctx->CreateArrayType(
  365 CompilerType AppleObjCTypeEncodingParser::RealizeType(

tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.h

   25   CompilerType RealizeType(clang::ASTContext &ast_ctx, const char *name,

tools/lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.cpp

  143 size_t ObjCLanguageRuntime::GetByteOffsetForIvar(CompilerType &parent_qual_type,
  308 CompilerType
  316 CompilerType ObjCLanguageRuntime::EncodingToType::RealizeType(
  330 bool ObjCLanguageRuntime::GetTypeBitSize(const CompilerType &compiler_type,
  401 llvm::Optional<CompilerType>
  402 ObjCLanguageRuntime::GetRuntimeType(CompilerType base_type) {
  403   CompilerType class_type;
  424   CompilerType complete_class(

tools/lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h

  121       CompilerType m_type;
  147     virtual CompilerType RealizeType(ClangASTContext &ast_ctx, const char *name,
  149     virtual CompilerType RealizeType(const char *name, bool for_expression);
  151     virtual CompilerType RealizeType(clang::ASTContext &ast_ctx,
  254   llvm::Optional<CompilerType> GetRuntimeType(CompilerType base_type) override;
  254   llvm::Optional<CompilerType> GetRuntimeType(CompilerType base_type) override;
  284   virtual size_t GetByteOffsetForIvar(CompilerType &parent_qual_type,
  302   bool GetTypeBitSize(const CompilerType &compiler_type,

tools/lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

  711   CompilerType clang_void_pointer_type
  713   CompilerType clang_char_pointer_type
  953   CompilerType clang_void_pointer_type

tools/lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp

   89         CompilerType void_ptr_type =

tools/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

   88   bool CompleteType(CompilerType &compiler_type) override { return false; }

tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h

   39                         lldb_private::CompilerType &compiler_type) = 0;

tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

  180   lldb_private::CompilerType dwo_type = dwo_type_sp->GetForwardCompilerType();
  182   lldb_private::CompilerType type =
  217   CompilerType type = ClangASTContext::GetTypeForDecl(tag_decl_ctx);
  420   CompilerType clang_type;
  690     CompilerType enumerator_clang_type;
  764     CompilerType return_clang_type;
  775     std::vector<CompilerType> function_param_types;
  829           CompilerType class_opaque_type;
  837               CompilerType type_clang_forward_type =
  944               CompilerType class_opaque_type =
 1172       CompilerType array_element_type = element_type->GetForwardCompilerType();
 1247     CompilerType pointee_clang_type = pointee_type->GetForwardCompilerType();
 1248     CompilerType class_clang_type = class_type->GetLayoutCompilerType();
 1315   CompilerType clang_type;
 1692       const CompilerType &class_opaque_type, const char *property_name,
 1693       const CompilerType &property_opaque_type, // The property type is only
 1739   CompilerType m_class_opaque_type;
 1741   CompilerType m_property_opaque_type;
 1778     CompilerType clang_type;
 1888                                                 CompilerType &clang_type) {
 2048               CompilerType base_class_type(
 2225     lldb_private::CompilerType &clang_type, bool is_signed,
 2390         std::vector<CompilerType> param_types;
 2452     const DWARFDIE &parent_die, CompilerType &class_clang_type,
 2812               CompilerType member_clang_type =
 2824                 CompilerType member_array_element_type;
 3023         CompilerType base_class_clang_type =
 3072     bool &has_template_params, std::vector<CompilerType> &function_param_types,

tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

   54                         lldb_private::CompilerType &compiler_type) override;
  108       const DWARFDIE &die, lldb_private::CompilerType &class_compiler_type,
  122                        std::vector<lldb_private::CompilerType> &function_args,
  126   size_t ParseChildEnumerators(lldb_private::CompilerType &compiler_type,

tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

  369   std::set<CompilerType> compiler_type_set;
  371     CompilerType compiler_type = type->GetForwardCompilerType();
 1385     const CompilerType &compiler_type) {
 1386   CompilerType compiler_type_no_qualifiers =
 1403 bool SymbolFileDWARF::CompleteType(CompilerType &compiler_type) {
 1417   CompilerType compiler_type_no_qualifiers =

tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

  133   bool CompleteType(lldb_private::CompilerType &compiler_type) override;
  237   HasForwardDeclForClangType(const lldb_private::CompilerType &compiler_type);

tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

  737 bool SymbolFileDWARFDebugMap::CompleteType(CompilerType &compiler_type) {

tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

   86   bool CompleteType(lldb_private::CompilerType &compiler_type) override;

tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp

  683   CompilerType ct = ToCompilerType(tag_qt);
  781   CompilerType ct =
  884   CompilerType ct = m_clang.CreateTypedefType(ToCompilerType(qt), uname.c_str(),
  895   CompilerType ct = m_clang.GetBasicType(type);
 1011   CompilerType func_ct = ToCompilerType(qt);
 1084     CompilerType param_type_ct(&m_clang, qt.getAsOpaquePtr());
 1107   CompilerType enum_ct = m_clang.CreateEnumerationType(
 1123   CompilerType array_ct = m_clang.CreateArrayType(ToCompilerType(element_type),
 1142   std::vector<CompilerType> arg_types;
 1157   CompilerType return_ct = ToCompilerType(return_type);
 1158   CompilerType func_sig_ast_type = m_clang.CreateFunctionType(
 1343 CompilerType PdbAstBuilder::ToCompilerType(clang::QualType qt) {

tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.h

   78   CompilerType ToCompilerType(clang::QualType qt);

tools/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

  449                                                      CompilerType ct) {
  469                                        CompilerType ct) {
  487                                                    CompilerType ct) {
  551                                             size_t size, CompilerType ct) {
  565                                                 CompilerType ct) {
  571                                                 CompilerType ct) {
  577                                                 CompilerType ct) {
  592                                             CompilerType ct) {
  607                                                CompilerType ct) {
  617                                                 CompilerType ct) {
  625 TypeSP SymbolFileNativePDB::CreateType(PdbTypeSymId type_id, CompilerType ct) {
 1561 bool SymbolFileNativePDB::CompleteType(CompilerType &compiler_type) {

tools/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

  108   bool CompleteType(CompilerType &compiler_type) override;
  162                                   CompilerType ct);
  165                                  CompilerType ct);
  166   lldb::TypeSP CreateSimpleType(llvm::codeview::TypeIndex ti, CompilerType ct);
  169                              CompilerType ct);
  172                              CompilerType ct);
  175                              CompilerType ct);
  178                                CompilerType ct);
  181                                   CompilerType ct);
  184                                    CompilerType ct);
  187                                       size_t size, CompilerType ct);
  208   lldb::TypeSP CreateType(PdbTypeSymId type_id, CompilerType ct);

tools/lldb/source/Plugins/SymbolFile/NativePDB/UdtRecordCompleter.cpp

   29                                        CompilerType &derived_ct,
  127   CompilerType member_ct = m_ast_builder.ToCompilerType(member_type);

tools/lldb/source/Plugins/SymbolFile/NativePDB/UdtRecordCompleter.h

   49   CompilerType &m_derived_ct;
   57   UdtRecordCompleter(PdbTypeSymId id, CompilerType &derived_ct,

tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

  102 static CompilerType
  161                                          CompilerType &compiler_type) {
  409     CompilerType clang_type = m_ast.GetTypeForIdentifier<clang::CXXRecordDecl>(
  482     CompilerType ast_enum = m_ast.GetTypeForIdentifier<clang::EnumDecl>(
  497       CompilerType builtin_type;
  554     CompilerType ast_typedef =
  558       CompilerType target_ast_type = target_type->GetFullCompilerType();
  608     std::vector<CompilerType> arg_list;
  624       CompilerType arg_ast_type = arg_type->GetFullCompilerType();
  636     CompilerType return_ast_type = return_type->GetFullCompilerType();
  643     CompilerType func_sig_ast_type =
  670     CompilerType element_ast_type = element_type->GetForwardCompilerType();
  681     CompilerType array_ast_type = m_ast.CreateArrayType(
  701     CompilerType builtin_ast_type = GetBuiltinTypeForPDBEncodingAndBitSize(
  732       CompilerType pointer_ast_type;
  745     CompilerType pointer_ast_type;
  776     lldb_private::CompilerType &compiler_type) {
  840       CompilerType class_parent_ct = class_parent_type->GetFullCompilerType();
 1127 bool PDBASTParser::AddEnumValue(CompilerType enum_type,
 1161   CompilerType underlying_type =
 1177     lldb_private::CompilerType &compiler_type,
 1217     lldb_private::CompilerType &record_type,
 1230     auto member_comp_type = member_type->GetLayoutCompilerType();
 1284     lldb_private::CompilerType &record_type, int record_kind,
 1294     auto base_comp_type = base_type->GetFullCompilerType();
 1333                                     lldb_private::CompilerType &record_type,
 1343                               lldb_private::CompilerType &record_type,
 1352   CompilerType method_comp_type = method_type->GetFullCompilerType();

tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.h

   49   bool CompleteTypeFromPDB(lldb_private::CompilerType &compiler_type);
   83   bool AddEnumValue(lldb_private::CompilerType enum_type,
   86                            lldb_private::CompilerType &compiler_type,
   90                    lldb_private::CompilerType &record_type,
   95                  lldb_private::CompilerType &record_type, int record_kind,
   99                         lldb_private::CompilerType &record_type,
  103                   lldb_private::CompilerType &record_type,

tools/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

  590 bool SymbolFilePDB::CompleteType(lldb_private::CompilerType &compiler_type) {

tools/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

   79   bool CompleteType(lldb_private::CompilerType &compiler_type) override;

tools/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

  241 bool SymbolFileSymtab::CompleteType(lldb_private::CompilerType &compiler_type) {

tools/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h

   68   bool CompleteType(lldb_private::CompilerType &compiler_type) override;

tools/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp

  180       CompilerType get_item_info_return_type =
  270   CompilerType clang_void_ptr_type =
  276   CompilerType clang_int_type = clang_ast_context->GetBasicType(eBasicTypeInt);
  281   CompilerType clang_uint64_type =

tools/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp

  181       CompilerType get_pending_items_return_type =
  273   CompilerType clang_void_ptr_type =
  279   CompilerType clang_int_type = clang_ast_context->GetBasicType(eBasicTypeInt);
  284   CompilerType clang_uint64_type =

tools/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.cpp

  195     CompilerType get_queues_return_type =
  274   CompilerType clang_void_ptr_type =
  280   CompilerType clang_int_type = clang_ast_context->GetBasicType(eBasicTypeInt);
  289   CompilerType clang_uint64_type =

tools/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.cpp

  190       CompilerType get_thread_item_info_return_type =
  276   CompilerType clang_void_ptr_type =
  282   CompilerType clang_int_type = clang_ast_context->GetBasicType(eBasicTypeInt);
  287   CompilerType clang_uint64_type =

tools/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp

  418       CompilerType uint16 =
  420       CompilerType dispatch_tsd_indexes_s = ast_ctx->CreateRecordType(

tools/lldb/source/Symbol/ClangASTContext.cpp

  217   CompilerType pointee_type;
  218   CompilerType this_type(valobj.GetCompilerType());
  844 CompilerType
  851 CompilerType ClangASTContext::GetBuiltinTypeForEncodingAndBitSize(
  990 CompilerType ClangASTContext::GetBasicType(ASTContext *ast,
 1008 CompilerType ClangASTContext::GetBasicType(lldb::BasicType basic_type) {
 1012 CompilerType ClangASTContext::GetBasicType(ASTContext *ast,
 1024 CompilerType ClangASTContext::GetBuiltinTypeForDWARFEncodingAndBitSize(
 1055           CompilerType complex_int_clang_type =
 1074         CompilerType complex_float_clang_type =
 1248 CompilerType ClangASTContext::GetUnknownAnyType(clang::ASTContext *ast) {
 1255 CompilerType ClangASTContext::GetCStringType(bool is_const) {
 1286 bool ClangASTContext::AreTypesSame(CompilerType type1, CompilerType type2,
 1286 bool ClangASTContext::AreTypesSame(CompilerType type1, CompilerType type2,
 1307 CompilerType ClangASTContext::GetTypeForDecl(void *opaque_decl) {
 1317 CompilerType ClangASTContext::GetTypeForDecl(clang::NamedDecl *decl) {
 1326 CompilerType ClangASTContext::GetTypeForDecl(TagDecl *decl) {
 1337 CompilerType ClangASTContext::GetTypeForDecl(ObjCInterfaceDecl *decl) {
 1350 CompilerType ClangASTContext::CreateRecordType(
 1634 CompilerType ClangASTContext::CreateClassTemplateSpecializationType(
 1752 CompilerType ClangASTContext::CreateObjCClass(const char *name,
 2025                                     const CompilerType &function_clang_type) {
 2055     const CompilerType &function_clang_type, int storage, bool is_inline) {
 2081 CompilerType ClangASTContext::CreateFunctionType(
 2082     ASTContext *ast, const CompilerType &result_type, const CompilerType *args,
 2082     ASTContext *ast, const CompilerType &result_type, const CompilerType *args,
 2125     const CompilerType &param_type, int storage, bool add_decl) {
 2146 CompilerType
 2147 ClangASTContext::CreateBlockPointerType(const CompilerType &function_type) {
 2156 CompilerType ClangASTContext::CreateArrayType(const CompilerType &element_type,
 2156 CompilerType ClangASTContext::CreateArrayType(const CompilerType &element_type,
 2188 CompilerType ClangASTContext::CreateStructForIdentifier(
 2190     const std::initializer_list<std::pair<const char *, CompilerType>>
 2193   CompilerType type;
 2213 CompilerType ClangASTContext::GetOrCreateStructForIdentifier(
 2215     const std::initializer_list<std::pair<const char *, CompilerType>>
 2218   CompilerType type;
 2227 CompilerType
 2230                                        const CompilerType &integer_clang_type,
 2260 CompilerType ClangASTContext::GetIntTypeFromBitSize(clang::ASTContext *ast,
 2314 CompilerType ClangASTContext::GetPointerSizedIntType(clang::ASTContext *ast,
 2551 ClangASTContext::GetDeclContextForType(const CompilerType &type) {
 2826                                   CompilerType *element_type_ptr,
 2916                                    CompilerType *element_type, uint64_t *size) {
 2987   CompilerType pointee_or_element_clang_type;
 3067                                         CompilerType *base_type_ptr) {
 3177 CompilerType
 3235     CompilerType *function_pointer_type_ptr) {
 3326                                     CompilerType *pointee_type) {
 3398     lldb::opaque_compiler_type_t type, CompilerType *pointee_type) {
 3484                                       CompilerType *pointee_type,
 3603 bool ClangASTContext::IsObjCClassType(const CompilerType &type) {
 3616 bool ClangASTContext::IsObjCObjectOrInterfaceType(const CompilerType &type) {
 3665                                             CompilerType *dynamic_pointee_type,
 3841 bool ClangASTContext::CanPassInRegisters(const CompilerType &type) {
 3853 bool ClangASTContext::GetCXXClassName(const CompilerType &type,
 3869 bool ClangASTContext::IsCXXClassType(const CompilerType &type) {
 3887 bool ClangASTContext::IsObjCObjectPointerType(const CompilerType &type,
 3888                                               CompilerType *class_type_ptr) {
 3945                              CompilerType *pointee_or_element_clang_type) {
 4415 CompilerType
 4427     CompilerType element_type(
 4440 CompilerType ClangASTContext::GetArrayType(lldb::opaque_compiler_type_t type,
 4465 CompilerType
 4485 CompilerType
 4505 CompilerType ClangASTContext::GetFunctionArgumentTypeAtIndex(
 4519 CompilerType
 4621   CompilerType clang_type;
 4759 CompilerType
 4767 CompilerType ClangASTContext::CreateTypedefType(
 4768     const CompilerType &type, const char *typedef_name,
 4798 CompilerType
 4808 CompilerType
 4829 CompilerType
 4839 CompilerType
 4849 CompilerType
 4859 CompilerType
 4869 CompilerType
 4879 CompilerType
 4919 CompilerType
 4933 CompilerType ClangASTContext::GetBasicTypeFromAST(lldb::BasicType basic_type) {
 5708 CompilerType ClangASTContext::GetBuiltinTypeByName(ConstString name) {
 5787     std::function<bool(const CompilerType &integer_type,
 5795       CompilerType integer_type(this,
 5959 CompilerType ClangASTContext::GetFieldAtIndex(lldb::opaque_compiler_type_t type,
 6211 CompilerType ClangASTContext::GetDirectBaseClassAtIndex(
 6334 CompilerType ClangASTContext::GetVirtualBaseClassAtIndex(
 6563 CompilerType ClangASTContext::GetChildCompilerTypeAtIndex(
 6663             CompilerType base_class_clang_type(
 6696           CompilerType field_clang_type(this,
 6744               CompilerType base_class_clang_type(
 6809                     CompilerType parent_ast_type(
 6853       CompilerType pointee_clang_type(GetPointeeType(type));
 6892         CompilerType element_type(this,
 6915         CompilerType element_type(this,
 6931     CompilerType pointee_clang_type(GetPointeeType(type));
 6974       CompilerType pointee_clang_type(
 7007     CompilerType typedefed_clang_type(
 7020     CompilerType elaborated_clang_type(
 7032     CompilerType elaborated_clang_type(
 7044     CompilerType paren_clang_type(this,
 7176             CompilerType field_type(this, field->getType().getAsOpaquePtr());
 7287               CompilerType superclass_clang_type(
 7308       CompilerType objc_object_clang_type(
 7361       CompilerType pointee_clang_type(this, pointee_type.getAsOpaquePtr());
 7370       CompilerType pointee_clang_type(GetPointeeType(type));
 7456             CompilerType base_class_clang_type(
 7520       CompilerType pointee_clang_type(
 7572       CompilerType pointee_type(
 7584       CompilerType pointee_type(
 7781 CompilerType
 7797 Optional<CompilerType::IntegralTemplateArgument>
 7815 CompilerType ClangASTContext::GetTypeForFormatters(void *type) {
 7821 clang::EnumDecl *ClangASTContext::GetAsEnumDecl(const CompilerType &type) {
 7829 clang::RecordDecl *ClangASTContext::GetAsRecordDecl(const CompilerType &type) {
 7837 clang::TagDecl *ClangASTContext::GetAsTagDecl(const CompilerType &type) {
 7842 ClangASTContext::GetAsTypedefDecl(const CompilerType &type) {
 7856 ClangASTContext::GetAsObjCInterfaceDecl(const CompilerType &type) {
 7866     const CompilerType &type, llvm::StringRef name,
 7867     const CompilerType &field_clang_type, AccessType access,
 7957 void ClangASTContext::BuildIndirectFields(const CompilerType &type) {
 8063 void ClangASTContext::SetIsPacked(const CompilerType &type) {
 8080     const CompilerType &type, llvm::StringRef name,
 8081     const CompilerType &var_type, AccessType access) {
 8123     const CompilerType &method_clang_type, lldb::AccessType access,
 8348     const CompilerType &type, const CompilerType &superclass_clang_type) {
 8348     const CompilerType &type, const CompilerType &superclass_clang_type) {
 8371     const CompilerType &type, const char *property_name,
 8372     const CompilerType &property_clang_type, clang::ObjCIvarDecl *ivar_decl,
 8386     CompilerType property_clang_type_to_access;
 8565 bool ClangASTContext::IsObjCClassTypeAndHasIVars(const CompilerType &type,
 8574     const CompilerType &type,
 8578     const CompilerType &method_clang_type, lldb::AccessType access,
 8767 bool ClangASTContext::StartTagDeclarationDefinition(const CompilerType &type) {
 8793     const CompilerType &type) {
 8862     const CompilerType &enum_type, const Declaration &decl, const char *name,
 8907     const CompilerType &enum_type, const Declaration &decl, const char *name,
 8909   CompilerType underlying_type =
 8920 CompilerType
 8936 CompilerType
 8937 ClangASTContext::CreateMemberPointerType(const CompilerType &type,
 8938                                          const CompilerType &pointee_type) {
 9072           CompilerType base_clang_type(this,
 9140         CompilerType field_clang_type(this, field_type.getAsOpaquePtr());
 9220       CompilerType element_clang_type(this, element_qual_type.getAsOpaquePtr());
 9271     CompilerType typedef_clang_type(this, typedef_qual_type.getAsOpaquePtr());
 9296     CompilerType elaborated_clang_type(this,
 9322     CompilerType elaborated_clang_type(this,
 9348     CompilerType desugar_clang_type(this, desugar_qual_type.getAsOpaquePtr());
 9489       CompilerType typedef_clang_type(this, typedef_qual_type.getAsOpaquePtr());
 9741 void ClangASTContext::DumpTypeName(const CompilerType &type) {
 9832     CompilerType clang_type = GetTypeForDecl(decl);
 9843     CompilerType clang_type = GetTypeForDecl(decl);
 9928 CompilerType ClangASTContext::DeclGetFunctionReturnType(void *opaque_decl) {
 9950 CompilerType ClangASTContext::DeclGetFunctionArgumentType(void *opaque_decl,
10072                                           CompilerType *child_type) {
10133                   CompilerType clang_type = ClangASTContext::GetTypeForDecl(nd);
10314     const CompilerType &return_type, const Address &function_address,

tools/lldb/source/Symbol/ClangASTImporter.cpp

   87 CompilerType ClangASTImporter::CopyType(ClangASTContext &dst_ast,
   88                                         const CompilerType &src_type) {
  404 bool ClangASTImporter::CanImport(const CompilerType &type) {
  481 bool ClangASTImporter::Import(const CompilerType &type) {
  556 bool ClangASTImporter::CompleteType(const CompilerType &compiler_type) {

tools/lldb/source/Symbol/ClangUtil.cpp

   17 bool ClangUtil::IsClangType(const CompilerType &ct) {
   27 QualType ClangUtil::GetQualType(const CompilerType &ct) {
   35 QualType ClangUtil::GetCanonicalQualType(const CompilerType &ct) {
   42 CompilerType ClangUtil::RemoveFastQualifiers(const CompilerType &ct) {
   42 CompilerType ClangUtil::RemoveFastQualifiers(const CompilerType &ct) {
   51 clang::TagDecl *ClangUtil::GetAsTagDecl(const CompilerType &type) {

tools/lldb/source/Symbol/CompilerDecl.cpp

   31 CompilerType CompilerDecl::GetFunctionReturnType() const {
   39 CompilerType CompilerDecl::GetFunctionArgumentType(size_t arg_idx) const {

tools/lldb/source/Symbol/CompilerType.cpp

   49 bool CompilerType::IsArrayType(CompilerType *element_type_ptr, uint64_t *size,
   64 bool CompilerType::IsVectorType(CompilerType *element_type,
  109 CompilerType::IsHomogeneousAggregate(CompilerType *base_type_ptr) const {
  121 CompilerType
  135     CompilerType *function_pointer_type_ptr) const {
  157 bool CompilerType::IsPointerType(CompilerType *pointee_type) const {
  166 bool CompilerType::IsPointerOrReferenceType(CompilerType *pointee_type) const {
  175 bool CompilerType::IsReferenceType(CompilerType *pointee_type,
  214 bool CompilerType::IsPossibleDynamicType(CompilerType *dynamic_pointee_type,
  250   CompilerType element_type;
  300     CompilerType *pointee_or_element_compiler_type) const {
  335 CompilerType CompilerType::GetArrayElementType(uint64_t *stride) const {
  342 CompilerType CompilerType::GetArrayType(uint64_t size) const {
  349 CompilerType CompilerType::GetCanonicalType() const {
  355 CompilerType CompilerType::GetFullyUnqualifiedType() const {
  368 CompilerType CompilerType::GetFunctionArgumentTypeAtIndex(size_t idx) const {
  375 CompilerType CompilerType::GetFunctionReturnType() const {
  396 CompilerType CompilerType::GetNonReferenceType() const {
  402 CompilerType CompilerType::GetPointeeType() const {
  409 CompilerType CompilerType::GetPointerType() const {
  416 CompilerType CompilerType::GetLValueReferenceType() const {
  423 CompilerType CompilerType::GetRValueReferenceType() const {
  430 CompilerType CompilerType::AddConstModifier() const {
  437 CompilerType CompilerType::AddVolatileModifier() const {
  444 CompilerType CompilerType::AddRestrictModifier() const {
  451 CompilerType
  460 CompilerType CompilerType::GetTypedefedType() const {
  469 CompilerType
  526     std::function<bool(const CompilerType &integer_type,
  539 CompilerType CompilerType::GetFieldAtIndex(size_t idx, std::string &name,
  561 CompilerType
  570 CompilerType
  580     const char *name, CompilerType *field_compiler_type_ptr,
  586     CompilerType field_compiler_type(
  598 CompilerType CompilerType::GetChildCompilerTypeAtIndex(
  671 CompilerType CompilerType::GetTypeTemplateArgument(size_t idx) const {
  678 llvm::Optional<CompilerType::IntegralTemplateArgument>
  685 CompilerType CompilerType::GetTypeForFormatters() const {
 1044 bool lldb_private::operator==(const lldb_private::CompilerType &lhs,
 1045                               const lldb_private::CompilerType &rhs) {
 1050 bool lldb_private::operator!=(const lldb_private::CompilerType &lhs,
 1051                               const lldb_private::CompilerType &rhs) {

tools/lldb/source/Symbol/DeclVendor.cpp

   18 std::vector<CompilerType> DeclVendor::FindTypes(ConstString name,
   22   std::vector<CompilerType> ret;
   26       if (auto type =

tools/lldb/source/Symbol/Function.cpp

  478 CompilerType Function::GetCompilerType() {

tools/lldb/source/Symbol/Type.cpp

  146            const CompilerType &compiler_type,
  471         CompilerType encoding_compiler_type =
  530         CompilerType void_compiler_type =
  629 CompilerType Type::GetFullCompilerType() {
  634 CompilerType Type::GetLayoutCompilerType() {
  639 CompilerType Type::GetForwardCompilerType() {
  771 void TypeAndOrName::SetCompilerType(CompilerType compiler_type) {
  797 TypeImpl::TypeImpl(const CompilerType &compiler_type)
  802 TypeImpl::TypeImpl(const lldb::TypeSP &type_sp, const CompilerType &dynamic)
  807 TypeImpl::TypeImpl(const CompilerType &static_type,
  808                    const CompilerType &dynamic_type)
  823 void TypeImpl::SetType(const CompilerType &compiler_type) {
  829                        const CompilerType &dynamic) {
  834 void TypeImpl::SetType(const CompilerType &compiler_type,
  835                        const CompilerType &dynamic) {
  998 CompilerType TypeImpl::GetCompilerType(bool prefer_dynamic) {
 1048 CompilerType TypeMemberFunctionImpl::GetType() const { return m_type; }
 1078 CompilerType TypeMemberFunctionImpl::GetReturnType() const {
 1091 CompilerType TypeMemberFunctionImpl::GetArgumentAtIndex(size_t idx) const {

tools/lldb/source/Symbol/TypeSystem.cpp

   79 CompilerType TypeSystem::GetArrayType(lldb::opaque_compiler_type_t type,
   84 CompilerType
   89 CompilerType
   94 CompilerType TypeSystem::AddConstModifier(lldb::opaque_compiler_type_t type) {
   98 CompilerType
  103 CompilerType
  108 CompilerType TypeSystem::CreateTypedef(lldb::opaque_compiler_type_t type,
  114 CompilerType TypeSystem::GetBuiltinTypeByName(ConstString name) {
  118 CompilerType TypeSystem::GetTypeForFormatters(void *type) {
  131 CompilerType TypeSystem::GetTypeTemplateArgument(opaque_compiler_type_t type,
  136 llvm::Optional<CompilerType::IntegralTemplateArgument>
  158 CompilerType TypeSystem::DeclGetFunctionReturnType(void *opaque_decl) {
  164 CompilerType TypeSystem::DeclGetFunctionArgumentType(void *opaque_decl,

tools/lldb/source/Symbol/Variable.cpp

  488     const CompilerType &compiler_type, CompletionRequest &request);
  495     const CompilerType &compiler_type, CompletionRequest &request);
  502     const CompilerType &compiler_type, CompletionRequest &request) {
  509       CompilerType base_class_type =
  522       CompilerType vbase_class_type =
  538       CompilerType member_compiler_type = compiler_type.GetFieldAtIndex(
  561     const CompilerType &compiler_type, CompletionRequest &request) {
  642           CompilerType pointee_type(compiler_type.GetPointeeType());
  725                   CompilerType variable_compiler_type(
  749   CompilerType compiler_type;

tools/lldb/source/Target/ABI.cpp

   84 ValueObjectSP ABI::GetReturnValueObject(Thread &thread, CompilerType &ast_type,

tools/lldb/source/Target/Language.cpp

  411         CompilerType compiler_type(match->GetFullCompilerType());

tools/lldb/source/Target/Process.cpp

 6002   CompilerType void_ptr_type =

tools/lldb/source/Target/StackFrame.cpp

 1375           CompilerType void_ptr_type =
 1603         CompilerType function_type = sc.function->GetCompilerType();
 1607         CompilerType return_type = function_type.GetFunctionReturnType();

tools/lldb/source/Target/Target.cpp

  773                                       const CompilerType *type, uint32_t kind,
 2211     lldb::LanguageType language, const CompilerType &return_type,

tools/lldb/source/Target/Thread.cpp

 1671         CompilerType return_type =

tools/lldb/source/Target/ThreadPlanCallFunction.cpp

   97     Thread &thread, const Address &function, const CompilerType &return_type,

tools/lldb/source/Target/ThreadPlanStepOut.cpp

  492     CompilerType return_compiler_type =

tools/lldb/unittests/Symbol/TestClangASTContext.cpp

  174   CompilerType type = ClangASTContext::GetBuiltinTypeForEncodingAndBitSize(
  238   CompilerType bool_type(m_ast.get(), bool_ctype);
  239   CompilerType record_type = m_ast->CreateRecordType(
  251   CompilerType record_type = m_ast->CreateRecordType(
  320   CompilerType int_type =
  324   CompilerType empty_base = m_ast->CreateRecordType(
  335   CompilerType non_empty_base = m_ast->CreateRecordType(
  351   CompilerType empty_derived = m_ast->CreateRecordType(
  374   CompilerType empty_derived2 = m_ast->CreateRecordType(
  415   CompilerType type = m_ast->CreateClassTemplateSpecializationType(spec_decl);
  421   CompilerType typedef_type = m_ast->CreateTypedefType(
  425   CompilerType auto_type(
  432   CompilerType int_type(m_ast.get(), m_ast->getASTContext()->IntTy.getAsOpaquePtr());
  433   for (CompilerType t : {type, typedef_type, auto_type}) {

usr/include/c++/7.4.0/bits/alloc_traits.h

  387       using allocator_type = allocator<_Tp>;
  389       using value_type = _Tp;
  392       using pointer = _Tp*;
  395       using const_pointer = const _Tp*;
  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  475 	{ __a.construct(__p, std::forward<_Args>(__args)...); }
  486 	destroy(allocator_type& __a, _Up* __p)

usr/include/c++/7.4.0/bits/allocator.h

  108     class allocator: public __allocator_base<_Tp>
  113       typedef _Tp*       pointer;
  114       typedef const _Tp* const_pointer;
  115       typedef _Tp&       reference;
  116       typedef const _Tp& const_reference;
  117       typedef _Tp        value_type;
  137 	allocator(const allocator<_Tp1>&) throw() { }

usr/include/c++/7.4.0/bits/move.h

   46     inline _GLIBCXX_CONSTEXPR _Tp*
   47     __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
   72     constexpr _Tp&&
   73     forward(typename std::remove_reference<_Tp>::type& __t) noexcept
   83     constexpr _Tp&&
   84     forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
   98     move(_Tp&& __t) noexcept
  104     : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
  105                     is_copy_constructible<_Tp>>::type { };
  136     inline _GLIBCXX17_CONSTEXPR _Tp*
  137     addressof(_Tp& __r) noexcept
  143     const _Tp* addressof(const _Tp&&) = delete;
  143     const _Tp* addressof(const _Tp&&) = delete;

usr/include/c++/7.4.0/bits/ptr_traits.h

  126       typedef _Tp* pointer;
  128       typedef _Tp  element_type;
  141       pointer_to(__make_not_void<element_type>& __r) noexcept
  141       pointer_to(__make_not_void<element_type>& __r) noexcept

usr/include/c++/7.4.0/bits/shared_ptr.h

  343 		   _Args&&... __args)
  344 	: __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
  688     allocate_shared(const _Alloc& __a, _Args&&... __args)
  691 			     std::forward<_Args>(__args)...);
  703     make_shared(_Args&&... __args)
  707 				       std::forward<_Args>(__args)...);

usr/include/c++/7.4.0/bits/shared_ptr_base.h

 1317 		     _Args&&... __args)
 1328 			      std::forward<_Args>(__args)...);

usr/include/c++/7.4.0/bits/std_function.h

  299       _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
  628       using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);

usr/include/c++/7.4.0/bits/stl_construct.h

   74     _Construct(_T1* __p, _Args&&... __args)
   74     _Construct(_T1* __p, _Args&&... __args)
   75     { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
   75     { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
   97     _Destroy(_Tp* __pointer)
  204 	     allocator<_Tp>&)

usr/include/c++/7.4.0/bits/stl_function.h

  108       typedef _Arg 	argument_type;   
  111       typedef _Result 	result_type;  
  121       typedef _Arg1 	first_argument_type; 
  124       typedef _Arg2 	second_argument_type;
  381     struct less : public binary_function<_Tp, _Tp, bool>
  381     struct less : public binary_function<_Tp, _Tp, bool>
  385       operator()(const _Tp& __x, const _Tp& __y) const
  385       operator()(const _Tp& __x, const _Tp& __y) const
  870     : public unary_function<_Tp,_Tp>
  870     : public unary_function<_Tp,_Tp>
  872       _Tp&
  873       operator()(_Tp& __x) const
  876       const _Tp&
  877       operator()(const _Tp& __x) const

usr/include/c++/7.4.0/bits/stl_iterator.h

 1224     __make_move_if_noexcept_iterator(_Tp* __i)

usr/include/c++/7.4.0/bits/stl_iterator_base_types.h

  181       typedef _Tp                         value_type;
  183       typedef _Tp*                        pointer;
  184       typedef _Tp&                        reference;
  192       typedef _Tp                         value_type;
  194       typedef const _Tp*                  pointer;
  195       typedef const _Tp&                  reference;

usr/include/c++/7.4.0/bits/stl_multimap.h

  101       typedef _Key					key_type;
  103       typedef std::pair<const _Key, _Tp>		value_type;

usr/include/c++/7.4.0/bits/stl_pair.h

  100 	return __and_<is_constructible<_T1, const _U1&>,
  100 	return __and_<is_constructible<_T1, const _U1&>,
  101 		      is_constructible<_T2, const _U2&>>::value;
  101 		      is_constructible<_T2, const _U2&>>::value;
  107 	return __and_<is_convertible<const _U1&, _T1>,
  107 	return __and_<is_convertible<const _U1&, _T1>,
  108 		      is_convertible<const _U2&, _T2>>::value;
  108 		      is_convertible<const _U2&, _T2>>::value;
  114 	return __and_<is_constructible<_T1, _U1&&>,
  114 	return __and_<is_constructible<_T1, _U1&&>,
  115 		      is_constructible<_T2, _U2&&>>::value;
  115 		      is_constructible<_T2, _U2&&>>::value;
  121 	return __and_<is_convertible<_U1&&, _T1>,
  121 	return __and_<is_convertible<_U1&&, _T1>,
  122 		      is_convertible<_U2&&, _T2>>::value;
  122 		      is_convertible<_U2&&, _T2>>::value;
  128 	using __do_converts = __and_<is_convertible<const _U1&, _T1>,
  128 	using __do_converts = __and_<is_convertible<const _U1&, _T1>,
  129 				  is_convertible<_U2&&, _T2>>;
  129 				  is_convertible<_U2&&, _T2>>;
  133 	return __and_<is_constructible<_T1, const _U1&>,
  133 	return __and_<is_constructible<_T1, const _U1&>,
  134 		      is_constructible<_T2, _U2&&>,
  134 		      is_constructible<_T2, _U2&&>,
  142 	using __do_converts = __and_<is_convertible<_U1&&, _T1>,
  142 	using __do_converts = __and_<is_convertible<_U1&&, _T1>,
  143 				  is_convertible<const _U2&, _T2>>;
  143 				  is_convertible<const _U2&, _T2>>;
  147 	return __and_<is_constructible<_T1, _U1&&>,
  147 	return __and_<is_constructible<_T1, _U1&&>,
  148 		      is_constructible<_T2, const _U2&&>,
  148 		      is_constructible<_T2, const _U2&&>,
  209     : private __pair_base<_T1, _T2>
  209     : private __pair_base<_T1, _T2>
  211       typedef _T1 first_type;    /// @c first_type is the first bound type
  212       typedef _T2 second_type;   /// @c second_type is the second bound type
  214       _T1 first;                 /// @c first is a copy of the first object
  215       _T2 second;                /// @c second is a copy of the second object
  252       using _PCCP = _PCC<true, _T1, _T2>;
  252       using _PCCP = _PCC<true, _T1, _T2>;
  260       constexpr pair(const _T1& __a, const _T2& __b)
  260       constexpr pair(const _T1& __a, const _T2& __b)
  269       explicit constexpr pair(const _T1& __a, const _T2& __b)
  269       explicit constexpr pair(const _T1& __a, const _T2& __b)
  283 			    _T1, _T2>;
  283 			    _T1, _T2>;
  291         constexpr pair(const pair<_U1, _U2>& __p)
  311        constexpr pair(_U1&& __x, const _T2& __y)
  311        constexpr pair(_U1&& __x, const _T2& __y)
  318        explicit constexpr pair(_U1&& __x, const _T2& __y)
  325        constexpr pair(const _T1& __x, _U2&& __y)
  325        constexpr pair(const _T1& __x, _U2&& __y)
  326        : first(__x), second(std::forward<_U2>(__y)) { }
  332        explicit pair(const _T1& __x, _U2&& __y)
  341 	constexpr pair(_U1&& __x, _U2&& __y)
  341 	constexpr pair(_U1&& __x, _U2&& __y)
  360 	constexpr pair(pair<_U1, _U2>&& __p)
  361 	: first(std::forward<_U1>(__p.first)),
  379 		__and_<is_copy_assignable<_T1>,
  380 		       is_copy_assignable<_T2>>::value,
  390 		__and_<is_move_assignable<_T1>,
  391 		       is_move_assignable<_T2>>::value,
  524     make_pair(_T1&& __x, _T2&& __y)

usr/include/c++/7.4.0/bits/stl_set.h

  110       typedef _Key     key_type;
  111       typedef _Key     value_type;
  119 	rebind<_Key>::other _Key_alloc_type;
  452 	emplace(_Args&&... __args)

usr/include/c++/7.4.0/bits/stl_tree.h

  218       typedef _Rb_tree_node<_Val>* _Link_type;
  231       __gnu_cxx::__aligned_membuf<_Val> _M_storage;
  233       _Val*
  237       const _Val*
  258       typedef _Tp  value_type;
  259       typedef _Tp& reference;
  260       typedef _Tp* pointer;
  265       typedef _Rb_tree_iterator<_Tp>        _Self;
  267       typedef _Rb_tree_node<_Tp>*           _Link_type;
  328       typedef _Tp        value_type;
  329       typedef const _Tp& reference;
  330       typedef const _Tp* pointer;
  332       typedef _Rb_tree_iterator<_Tp> iterator;
  337       typedef _Rb_tree_const_iterator<_Tp>        _Self;
  339       typedef const _Rb_tree_node<_Tp>*           _Link_type;
  447         rebind<_Rb_tree_node<_Val> >::other _Node_allocator;
  454       typedef _Rb_tree_node<_Val>* 		_Link_type;
  455       typedef const _Rb_tree_node<_Val>*	_Const_Link_type;
  554 	  operator()(_Arg&& __arg) const
  563       typedef _Key 				key_type;
  564       typedef _Val 				value_type;
  621 	_M_construct_node(_Link_type __node, _Args&&... __args)
  625 	      ::new(__node) _Rb_tree_node<_Val>;
  640         _M_create_node(_Args&&... __args)
  758       static const _Key&
  782       static const _Key&
  834 	_M_insert_(_Base_ptr __x, _Base_ptr __y, _Arg&& __v, _NodeGen&);
  894 		     const _Key& __k);
  898 		     const _Key& __k) const;
  902 		     const _Key& __k);
  906 		     const _Key& __k) const;
 1011         _M_insert_unique(_Arg&& __x);
 1043 	_M_emplace_unique(_Args&&... __args);

usr/include/c++/7.4.0/bits/stl_uninitialized.h

  288 			   _ForwardIterator __result, allocator<_Tp>&)

usr/include/c++/7.4.0/bits/stl_vector.h

   77 	rebind<_Tp>::other _Tp_alloc_type;
  216     class vector : protected _Vector_base<_Tp, _Alloc>
  227       typedef _Vector_base<_Tp, _Alloc>			_Base;
  232       typedef _Tp					value_type;
  919       _Tp*
  923       const _Tp*
  962 	emplace_back(_Args&&... __args);
 1483 	_M_realloc_insert(iterator __position, _Args&&... __args);
 1561 	_Up*
 1562 	_M_data_ptr(_Up* __ptr) const _GLIBCXX_NOEXCEPT

usr/include/c++/7.4.0/bits/unordered_map.h

  103       typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc>  _Hashtable;

usr/include/c++/7.4.0/bits/vector.tcc

  101 				     std::forward<_Args>(__args)...);
  105 	  _M_realloc_insert(end(), std::forward<_Args>(__args)...);
  418 				   std::forward<_Args>(__args)...);

usr/include/c++/7.4.0/ext/aligned_buffer.h

   52       struct _Tp2 { _Tp _M_t; };
   54       alignas(__alignof__(_Tp2::_M_t)) unsigned char _M_storage[sizeof(_Tp)];
   69       _Tp*
   73       const _Tp*

usr/include/c++/7.4.0/ext/alloc_traits.h

  117       { typedef typename _Base_type::template rebind_alloc<_Tp> other; };

usr/include/c++/7.4.0/ext/new_allocator.h

   63       typedef _Tp*       pointer;
   64       typedef const _Tp* const_pointer;
   65       typedef _Tp&       reference;
   66       typedef const _Tp& const_reference;
   67       typedef _Tp        value_type;
   84 	new_allocator(const new_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPT { }
  111 	return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
  130       { return size_t(-1) / sizeof(_Tp); }
  135 	construct(_Up* __p, _Args&&... __args)
  135 	construct(_Up* __p, _Args&&... __args)
  136 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
  136 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
  140 	destroy(_Up* __p) { __p->~_Up(); }

usr/include/c++/7.4.0/initializer_list

   50       typedef _E 		value_type;
   51       typedef const _E& 	reference;
   52       typedef const _E& 	const_reference;
   54       typedef const _E* 	iterator;
   55       typedef const _E* 	const_iterator;

usr/include/c++/7.4.0/type_traits

  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  326     : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
  354     : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
  381     : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
  567     : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  631     : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  798       typedef decltype(__test<_Tp>(0)) type;
  811                remove_all_extents<_Tp>::type>::type
  825     : public __is_destructible_safe<_Tp>::type
  984       typedef decltype(__test<_Tp, _Arg>(0)) type;
  989     : public __and_<is_destructible<_Tp>,
  990                     __is_direct_constructible_impl<_Tp, _Arg>>
 1072 			 __is_direct_constructible_ref_cast<_Tp, _Arg>,
 1073 			 __is_direct_constructible_new_safe<_Tp, _Arg>
 1079     : public __is_direct_constructible_new<_Tp, _Arg>::type
 1119     : public __is_direct_constructible<_Tp, _Arg>
 1130     : public __is_constructible_impl<_Tp, _Args...>::type
 1142     : public is_constructible<_Tp, const _Tp&>
 1142     : public is_constructible<_Tp, const _Tp&>
 1148     : public __is_copy_constructible_impl<_Tp>
 1160     : public is_constructible<_Tp, _Tp&&>
 1160     : public is_constructible<_Tp, _Tp&&>
 1166     : public __is_move_constructible_impl<_Tp>
 1215     : public __and_<is_constructible<_Tp, _Args...>,
 1216 		    __is_nt_constructible_impl<_Tp, _Args...>>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1252     : public __is_nothrow_move_constructible_impl<_Tp>
 1286     : public is_assignable<_Tp&, const _Tp&>
 1286     : public is_assignable<_Tp&, const _Tp&>
 1292     : public __is_copy_assignable_impl<_Tp>
 1304     : public is_assignable<_Tp&, _Tp&&>
 1304     : public is_assignable<_Tp&, _Tp&&>
 1310     : public __is_move_assignable_impl<_Tp>
 1526 	static void __test_aux(_To1);
 1538       typedef decltype(__test<_From, _To>(0)) type;
 1545     : public __is_convertible_helper<_From, _To>::type
 1554     { typedef _Tp     type; };
 1558     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1629     { typedef _Tp   type; };
 1633     { typedef _Tp   type; };
 1659     { typedef _Tp&&   type; };
 1955     { typedef _Tp     type; };
 2131       typedef _Tp __type;
 2171     { typedef _Iffalse type; };

usr/include/c++/7.4.0/utility

  180     { typedef _Tp2 type; };
  190         __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
  200         __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
  224     constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
  225     get(std::pair<_Tp1, _Tp2>& __in) noexcept
  229     constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
  230     get(std::pair<_Tp1, _Tp2>&& __in) noexcept
  234     constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
  235     get(const std::pair<_Tp1, _Tp2>& __in) noexcept

utils/unittest/googletest/include/gtest/gtest-printers.h

  140   static void PrintValue(const T& value, ::std::ostream* os) {
  205     ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
  206   TypeWithoutFormatter<T,
  207       (internal::IsAProtocolMessage<T>::value ? kProtobuf :
  208        internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
  223 void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
  276   static ::std::string Format(const ToPrint& value) {
  351     const T1& value, const T2& /* other_operand */) {
  351     const T1& value, const T2& /* other_operand */) {
  352   return FormatForComparison<T1, T2>::Format(value);
  352   return FormatForComparison<T1, T2>::Format(value);
  366 void UniversalPrint(const T& value, ::std::ostream* os);
  373                     const C& container, ::std::ostream* os) {
  439                     const T& value, ::std::ostream* os) {
  455 void PrintTo(const T& value, ::std::ostream* os) {
  478   DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
  699   static void Print(const T& value, ::std::ostream* os) {
  784   static void Print(const T& value, ::std::ostream* os) {
  856   typedef T T1;
  983   internal::UniversalTersePrinter<T>::Print(value, &ss);

utils/unittest/googletest/include/gtest/gtest.h

  273       const T& success,
  275           !internal::ImplicitlyConvertible<T, AssertionResult>::value>::type*
 1377                                    const T1& lhs, const T2& rhs) {
 1377                                    const T1& lhs, const T2& rhs) {
 1389                             const T1& lhs,
 1390                             const T2& rhs) {
 1419                                  const T1& lhs,
 1420                                  const T2& rhs) {

utils/unittest/googletest/include/gtest/internal/custom/raw-ostream.h

   29   static const T& printable(const T& V) { return V; }
   29   static const T& printable(const T& V) { return V; }
   35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
   35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
   37   return StreamSwitch<T>::printable(V);

utils/unittest/googletest/include/gtest/internal/gtest-internal.h

   94 ::std::string PrintToString(const T& value);
  830 struct AddReference { typedef T& type; };  // NOLINT
  863   static typename AddReference<From>::type MakeFrom();