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 
20 CGCXXABI::~CGCXXABI() { }
21 
22 static void ErrorUnsupportedABI(CodeGenFunction &CGF,
23                                 StringRef S) {
24   DiagnosticsEngine &Diags = CGF.CGM.getDiags();
25   unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
26                                           "cannot yet compile %1 in this ABI");
27   Diags.Report(CGF.getContext().getFullLoc(CGF.CurCodeDecl->getLocation()),
28                DiagID)
29     << S;
30 }
31 
32 static llvm::Constant *GetBogusMemberPointer(CodeGenModule &CGM,
33                                              QualType T) {
34   return llvm::Constant::getNullValue(CGM.getTypes().ConvertType(T));
35 }
36 
37 llvm::Type *
38 CGCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
39   return CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
40 }
41 
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 
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 
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 *
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 *
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 *
93 CGCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
94   return GetBogusMemberPointer(CGM, QualType(MPT, 0));
95 }
96 
97 llvm::Constant *CGCXXABI::EmitMemberPointer(const CXXMethodDecl *MD) {
98   return GetBogusMemberPointer(CGM,
99                          CGM.getContext().getMemberPointerType(MD->getType(),
100                                          MD->getParent()->getTypeForDecl()));
101 }
102 
103 llvm::Constant *CGCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
104                                                 CharUnits offset) {
105   return GetBogusMemberPointer(CGM, QualType(MPT, 0));
106 }
107 
108 llvm::Constant *CGCXXABI::EmitMemberPointer(const APValue &MP, QualType MPT) {
109   return GetBogusMemberPointer(CGM, MPT);
110 }
111 
112 bool CGCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
113   // Fake answer.
114   return true;
115 }
116 
117 void CGCXXABI::BuildThisParam(CodeGenFunction &CGF, FunctionArgList &params) {
118   const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
119 
120   // FIXME: I'm not entirely sure I like using a fake decl just for code
121   // generation. Maybe we can come up with a better way?
122   ImplicitParamDecl *ThisDecl
123     = ImplicitParamDecl::Create(CGM.getContext(), 0, MD->getLocation(),
124                                 &CGM.getContext().Idents.get("this"),
125                                 MD->getThisType(CGM.getContext()));
126   params.push_back(ThisDecl);
127   getThisDecl(CGF) = ThisDecl;
128 }
129 
130 void CGCXXABI::EmitThisParam(CodeGenFunction &CGF) {
131   /// Initialize the 'this' slot.
132   assert(getThisDecl(CGF) && "no 'this' variable for function");
133   getThisValue(CGF)
134     = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)),
135                              "this");
136 }
137 
138 void CGCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
139                                    RValue RV, QualType ResultType) {
140   CGF.EmitReturnOfRValue(RV, ResultType);
141 }
142 
143 CharUnits CGCXXABI::GetArrayCookieSize(const CXXNewExpr *expr) {
144   return CharUnits::Zero();
145 }
146 
147 llvm::Value *CGCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
148                                              llvm::Value *NewPtr,
149                                              llvm::Value *NumElements,
150                                              const CXXNewExpr *expr,
151                                              QualType ElementType) {
152   // Should never be called.
153   ErrorUnsupportedABI(CGF, "array cookie initialization");
154   return 0;
155 }
156 
157 void CGCXXABI::ReadArrayCookie(CodeGenFunction &CGF, llvm::Value *Ptr,
158                                const CXXDeleteExpr *expr, QualType ElementType,
159                                llvm::Value *&NumElements,
160                                llvm::Value *&AllocPtr, CharUnits &CookieSize) {
161   ErrorUnsupportedABI(CGF, "array cookie reading");
162 
163   // This should be enough to avoid assertions.
164   NumElements = 0;
165   AllocPtr = llvm::Constant::getNullValue(CGF.Builder.getInt8PtrTy());
166   CookieSize = CharUnits::Zero();
167 }
168 
169 void CGCXXABI::EmitGuardedInit(CodeGenFunction &CGF,
170                                const VarDecl &D,
171                                llvm::GlobalVariable *GV) {
172   ErrorUnsupportedABI(CGF, "static local variable initialization");
173 }
174