1 //===----- CGCXXABI.cpp - Interface to C++ ABIs -----------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This provides an abstract class for C++ code generation. Concrete subclasses
11 // of this implement code generation for specific C++ ABIs.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #include "CGCXXABI.h"
16
17 using namespace clang;
18 using namespace CodeGen;
19
~CGCXXABI()20 CGCXXABI::~CGCXXABI() { }
21
ErrorUnsupportedABI(CodeGenFunction & CGF,llvm::StringRef S)22 static void ErrorUnsupportedABI(CodeGenFunction &CGF,
23 llvm::StringRef S) {
24 Diagnostic &Diags = CGF.CGM.getDiags();
25 unsigned DiagID = Diags.getCustomDiagID(Diagnostic::Error,
26 "cannot yet compile %1 in this ABI");
27 Diags.Report(CGF.getContext().getFullLoc(CGF.CurCodeDecl->getLocation()),
28 DiagID)
29 << S;
30 }
31
GetBogusMemberPointer(CodeGenModule & CGM,QualType T)32 static llvm::Constant *GetBogusMemberPointer(CodeGenModule &CGM,
33 QualType T) {
34 return llvm::Constant::getNullValue(CGM.getTypes().ConvertType(T));
35 }
36
37 llvm::Type *
ConvertMemberPointerType(const MemberPointerType * MPT)38 CGCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
39 return CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
40 }
41
EmitLoadOfMemberFunctionPointer(CodeGenFunction & CGF,llvm::Value * & This,llvm::Value * MemPtr,const MemberPointerType * MPT)42 llvm::Value *CGCXXABI::EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
43 llvm::Value *&This,
44 llvm::Value *MemPtr,
45 const MemberPointerType *MPT) {
46 ErrorUnsupportedABI(CGF, "calls through member pointers");
47
48 const FunctionProtoType *FPT =
49 MPT->getPointeeType()->getAs<FunctionProtoType>();
50 const CXXRecordDecl *RD =
51 cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
52 llvm::FunctionType *FTy =
53 CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(RD, FPT),
54 FPT->isVariadic());
55 return llvm::Constant::getNullValue(FTy->getPointerTo());
56 }
57
EmitMemberDataPointerAddress(CodeGenFunction & CGF,llvm::Value * Base,llvm::Value * MemPtr,const MemberPointerType * MPT)58 llvm::Value *CGCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF,
59 llvm::Value *Base,
60 llvm::Value *MemPtr,
61 const MemberPointerType *MPT) {
62 ErrorUnsupportedABI(CGF, "loads of member pointers");
63 llvm::Type *Ty = CGF.ConvertType(MPT->getPointeeType())->getPointerTo();
64 return llvm::Constant::getNullValue(Ty);
65 }
66
EmitMemberPointerConversion(CodeGenFunction & CGF,const CastExpr * E,llvm::Value * Src)67 llvm::Value *CGCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
68 const CastExpr *E,
69 llvm::Value *Src) {
70 ErrorUnsupportedABI(CGF, "member function pointer conversions");
71 return GetBogusMemberPointer(CGM, E->getType());
72 }
73
74 llvm::Value *
EmitMemberPointerComparison(CodeGenFunction & CGF,llvm::Value * L,llvm::Value * R,const MemberPointerType * MPT,bool Inequality)75 CGCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
76 llvm::Value *L,
77 llvm::Value *R,
78 const MemberPointerType *MPT,
79 bool Inequality) {
80 ErrorUnsupportedABI(CGF, "member function pointer comparison");
81 return CGF.Builder.getFalse();
82 }
83
84 llvm::Value *
EmitMemberPointerIsNotNull(CodeGenFunction & CGF,llvm::Value * MemPtr,const MemberPointerType * MPT)85 CGCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
86 llvm::Value *MemPtr,
87 const MemberPointerType *MPT) {
88 ErrorUnsupportedABI(CGF, "member function pointer null testing");
89 return CGF.Builder.getFalse();
90 }
91
92 llvm::Constant *
EmitMemberPointerConversion(llvm::Constant * C,const CastExpr * E)93 CGCXXABI::EmitMemberPointerConversion(llvm::Constant *C, const CastExpr *E) {
94 return GetBogusMemberPointer(CGM, E->getType());
95 }
96
97 llvm::Constant *
EmitNullMemberPointer(const MemberPointerType * MPT)98 CGCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
99 return GetBogusMemberPointer(CGM, QualType(MPT, 0));
100 }
101
EmitMemberPointer(const CXXMethodDecl * MD)102 llvm::Constant *CGCXXABI::EmitMemberPointer(const CXXMethodDecl *MD) {
103 return GetBogusMemberPointer(CGM,
104 CGM.getContext().getMemberPointerType(MD->getType(),
105 MD->getParent()->getTypeForDecl()));
106 }
107
EmitMemberDataPointer(const MemberPointerType * MPT,CharUnits offset)108 llvm::Constant *CGCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
109 CharUnits offset) {
110 return GetBogusMemberPointer(CGM, QualType(MPT, 0));
111 }
112
isZeroInitializable(const MemberPointerType * MPT)113 bool CGCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
114 // Fake answer.
115 return true;
116 }
117
BuildThisParam(CodeGenFunction & CGF,FunctionArgList & params)118 void CGCXXABI::BuildThisParam(CodeGenFunction &CGF, FunctionArgList ¶ms) {
119 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
120
121 // FIXME: I'm not entirely sure I like using a fake decl just for code
122 // generation. Maybe we can come up with a better way?
123 ImplicitParamDecl *ThisDecl
124 = ImplicitParamDecl::Create(CGM.getContext(), 0, MD->getLocation(),
125 &CGM.getContext().Idents.get("this"),
126 MD->getThisType(CGM.getContext()));
127 params.push_back(ThisDecl);
128 getThisDecl(CGF) = ThisDecl;
129 }
130
EmitThisParam(CodeGenFunction & CGF)131 void CGCXXABI::EmitThisParam(CodeGenFunction &CGF) {
132 /// Initialize the 'this' slot.
133 assert(getThisDecl(CGF) && "no 'this' variable for function");
134 getThisValue(CGF)
135 = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)),
136 "this");
137 }
138
EmitReturnFromThunk(CodeGenFunction & CGF,RValue RV,QualType ResultType)139 void CGCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
140 RValue RV, QualType ResultType) {
141 CGF.EmitReturnOfRValue(RV, ResultType);
142 }
143
GetArrayCookieSize(const CXXNewExpr * expr)144 CharUnits CGCXXABI::GetArrayCookieSize(const CXXNewExpr *expr) {
145 return CharUnits::Zero();
146 }
147
InitializeArrayCookie(CodeGenFunction & CGF,llvm::Value * NewPtr,llvm::Value * NumElements,const CXXNewExpr * expr,QualType ElementType)148 llvm::Value *CGCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
149 llvm::Value *NewPtr,
150 llvm::Value *NumElements,
151 const CXXNewExpr *expr,
152 QualType ElementType) {
153 // Should never be called.
154 ErrorUnsupportedABI(CGF, "array cookie initialization");
155 return 0;
156 }
157
ReadArrayCookie(CodeGenFunction & CGF,llvm::Value * Ptr,const CXXDeleteExpr * expr,QualType ElementType,llvm::Value * & NumElements,llvm::Value * & AllocPtr,CharUnits & CookieSize)158 void CGCXXABI::ReadArrayCookie(CodeGenFunction &CGF, llvm::Value *Ptr,
159 const CXXDeleteExpr *expr, QualType ElementType,
160 llvm::Value *&NumElements,
161 llvm::Value *&AllocPtr, CharUnits &CookieSize) {
162 ErrorUnsupportedABI(CGF, "array cookie reading");
163
164 // This should be enough to avoid assertions.
165 NumElements = 0;
166 AllocPtr = llvm::Constant::getNullValue(CGF.Builder.getInt8PtrTy());
167 CookieSize = CharUnits::Zero();
168 }
169
EmitGuardedInit(CodeGenFunction & CGF,const VarDecl & D,llvm::GlobalVariable * GV)170 void CGCXXABI::EmitGuardedInit(CodeGenFunction &CGF,
171 const VarDecl &D,
172 llvm::GlobalVariable *GV) {
173 ErrorUnsupportedABI(CGF, "static local variable initialization");
174 }
175