mirror of
https://github.com/llvm/llvm-project.git
synced 2025-05-16 21:16:06 +00:00
2575631c0f
and we later find the definition, make sure that we add the definition (not the declaration) to the list of deferred definitions to emit. Fixes PR8864. Thanks to Nick Lewycky for testing this patch out llvm-svn: 125157
128 lines
3.6 KiB
C++
128 lines
3.6 KiB
C++
//===--- GlobalDecl.h - Global declaration holder ---------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// A GlobalDecl can hold either a regular variable/function or a C++ ctor/dtor
|
|
// together with its type.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef CLANG_CODEGEN_GLOBALDECL_H
|
|
#define CLANG_CODEGEN_GLOBALDECL_H
|
|
|
|
#include "clang/AST/DeclCXX.h"
|
|
#include "clang/AST/DeclObjC.h"
|
|
#include "clang/Basic/ABI.h"
|
|
|
|
namespace clang {
|
|
|
|
namespace CodeGen {
|
|
|
|
/// GlobalDecl - represents a global declaration. This can either be a
|
|
/// CXXConstructorDecl and the constructor type (Base, Complete).
|
|
/// a CXXDestructorDecl and the destructor type (Base, Complete) or
|
|
/// a VarDecl, a FunctionDecl or a BlockDecl.
|
|
class GlobalDecl {
|
|
llvm::PointerIntPair<const Decl*, 2> Value;
|
|
|
|
void Init(const Decl *D) {
|
|
assert(!isa<CXXConstructorDecl>(D) && "Use other ctor with ctor decls!");
|
|
assert(!isa<CXXDestructorDecl>(D) && "Use other ctor with dtor decls!");
|
|
|
|
Value.setPointer(D);
|
|
}
|
|
|
|
public:
|
|
GlobalDecl() {}
|
|
|
|
GlobalDecl(const VarDecl *D) { Init(D);}
|
|
GlobalDecl(const FunctionDecl *D) { Init(D); }
|
|
GlobalDecl(const BlockDecl *D) { Init(D); }
|
|
GlobalDecl(const ObjCMethodDecl *D) { Init(D); }
|
|
|
|
GlobalDecl(const CXXConstructorDecl *D, CXXCtorType Type)
|
|
: Value(D, Type) {}
|
|
GlobalDecl(const CXXDestructorDecl *D, CXXDtorType Type)
|
|
: Value(D, Type) {}
|
|
|
|
GlobalDecl getCanonicalDecl() const {
|
|
GlobalDecl CanonGD;
|
|
CanonGD.Value.setPointer(Value.getPointer()->getCanonicalDecl());
|
|
CanonGD.Value.setInt(Value.getInt());
|
|
|
|
return CanonGD;
|
|
}
|
|
|
|
const Decl *getDecl() const { return Value.getPointer(); }
|
|
|
|
CXXCtorType getCtorType() const {
|
|
assert(isa<CXXConstructorDecl>(getDecl()) && "Decl is not a ctor!");
|
|
return static_cast<CXXCtorType>(Value.getInt());
|
|
}
|
|
|
|
CXXDtorType getDtorType() const {
|
|
assert(isa<CXXDestructorDecl>(getDecl()) && "Decl is not a dtor!");
|
|
return static_cast<CXXDtorType>(Value.getInt());
|
|
}
|
|
|
|
friend bool operator==(const GlobalDecl &LHS, const GlobalDecl &RHS) {
|
|
return LHS.Value == RHS.Value;
|
|
}
|
|
|
|
void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }
|
|
|
|
static GlobalDecl getFromOpaquePtr(void *P) {
|
|
GlobalDecl GD;
|
|
GD.Value.setFromOpaqueValue(P);
|
|
return GD;
|
|
}
|
|
|
|
GlobalDecl getWithDecl(const Decl *D) {
|
|
GlobalDecl Result(*this);
|
|
Result.Value.setPointer(D);
|
|
return Result;
|
|
}
|
|
};
|
|
|
|
} // end namespace CodeGen
|
|
} // end namespace clang
|
|
|
|
namespace llvm {
|
|
template<class> struct DenseMapInfo;
|
|
|
|
template<> struct DenseMapInfo<clang::CodeGen::GlobalDecl> {
|
|
static inline clang::CodeGen::GlobalDecl getEmptyKey() {
|
|
return clang::CodeGen::GlobalDecl();
|
|
}
|
|
|
|
static inline clang::CodeGen::GlobalDecl getTombstoneKey() {
|
|
return clang::CodeGen::GlobalDecl::
|
|
getFromOpaquePtr(reinterpret_cast<void*>(-1));
|
|
}
|
|
|
|
static unsigned getHashValue(clang::CodeGen::GlobalDecl GD) {
|
|
return DenseMapInfo<void*>::getHashValue(GD.getAsOpaquePtr());
|
|
}
|
|
|
|
static bool isEqual(clang::CodeGen::GlobalDecl LHS,
|
|
clang::CodeGen::GlobalDecl RHS) {
|
|
return LHS == RHS;
|
|
}
|
|
|
|
};
|
|
|
|
// GlobalDecl isn't *technically* a POD type. However, its copy constructor,
|
|
// copy assignment operator, and destructor are all trivial.
|
|
template <>
|
|
struct isPodLike<clang::CodeGen::GlobalDecl> {
|
|
static const bool value = true;
|
|
};
|
|
} // end namespace llvm
|
|
|
|
#endif
|