blob: d78082463217226c56a965ad70cbf64e3664bd03 [file] [log] [blame]
Chris Lattner7f02f722007-08-24 05:35:26 +00001//===--- CGExprScalar.cpp - Emit LLVM Code for Scalar Exprs ---------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner7f02f722007-08-24 05:35:26 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This contains code to emit Expr nodes with scalar LLVM types as LLVM code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenFunction.h"
15#include "CodeGenModule.h"
Daniel Dunbarde7fb842008-08-11 05:00:27 +000016#include "clang/AST/ASTContext.h"
Daniel Dunbar98c5ead2008-08-12 05:08:18 +000017#include "clang/AST/DeclObjC.h"
Anders Carlsson19cc4ab2009-07-18 19:43:29 +000018#include "clang/AST/RecordLayout.h"
Daniel Dunbarde7fb842008-08-11 05:00:27 +000019#include "clang/AST/StmtVisitor.h"
Chris Lattner25ddea72008-04-20 00:50:39 +000020#include "clang/Basic/TargetInfo.h"
Chris Lattner7f02f722007-08-24 05:35:26 +000021#include "llvm/Constants.h"
22#include "llvm/Function.h"
Anders Carlsson85f9bce2007-10-29 05:01:08 +000023#include "llvm/GlobalVariable.h"
Anders Carlsson7c50aca2007-10-15 20:28:48 +000024#include "llvm/Intrinsics.h"
Mike Stump2add4732009-04-01 20:28:16 +000025#include "llvm/Module.h"
Chris Lattner7f02f722007-08-24 05:35:26 +000026#include "llvm/Support/Compiler.h"
Chris Lattnerf7b5ea92008-11-12 08:38:24 +000027#include "llvm/Support/CFG.h"
Mike Stump4e7a1f72009-02-21 20:00:35 +000028#include "llvm/Target/TargetData.h"
Chris Lattnerc89bf692008-01-03 07:05:49 +000029#include <cstdarg>
Ted Kremenek6aad91a2007-12-10 23:44:32 +000030
Chris Lattner7f02f722007-08-24 05:35:26 +000031using namespace clang;
32using namespace CodeGen;
33using llvm::Value;
34
35//===----------------------------------------------------------------------===//
36// Scalar Expression Emitter
37//===----------------------------------------------------------------------===//
38
39struct BinOpInfo {
40 Value *LHS;
41 Value *RHS;
Chris Lattner1f1ded92007-08-24 21:00:35 +000042 QualType Ty; // Computation Type.
Chris Lattner7f02f722007-08-24 05:35:26 +000043 const BinaryOperator *E;
44};
45
46namespace {
47class VISIBILITY_HIDDEN ScalarExprEmitter
48 : public StmtVisitor<ScalarExprEmitter, Value*> {
49 CodeGenFunction &CGF;
Daniel Dunbar45d196b2008-11-01 01:53:16 +000050 CGBuilderTy &Builder;
Mike Stump7f79f9b2009-05-29 15:46:01 +000051 bool IgnoreResultAssign;
Owen Andersona1cf15f2009-07-14 23:10:40 +000052 llvm::LLVMContext &VMContext;
Chris Lattner7f02f722007-08-24 05:35:26 +000053public:
54
Mike Stump7f79f9b2009-05-29 15:46:01 +000055 ScalarExprEmitter(CodeGenFunction &cgf, bool ira=false)
Owen Andersona1cf15f2009-07-14 23:10:40 +000056 : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira),
57 VMContext(cgf.getLLVMContext()) {
Chris Lattner7f02f722007-08-24 05:35:26 +000058 }
Chris Lattner7f02f722007-08-24 05:35:26 +000059
60 //===--------------------------------------------------------------------===//
61 // Utilities
62 //===--------------------------------------------------------------------===//
63
Mike Stump7f79f9b2009-05-29 15:46:01 +000064 bool TestAndClearIgnoreResultAssign() {
Chris Lattner9c10fcf2009-07-08 01:08:03 +000065 bool I = IgnoreResultAssign;
66 IgnoreResultAssign = false;
67 return I;
68 }
Mike Stump7f79f9b2009-05-29 15:46:01 +000069
Chris Lattner7f02f722007-08-24 05:35:26 +000070 const llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); }
71 LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); }
72
73 Value *EmitLoadOfLValue(LValue LV, QualType T) {
Chris Lattner9b655512007-08-31 22:49:20 +000074 return CGF.EmitLoadOfLValue(LV, T).getScalarVal();
Chris Lattner7f02f722007-08-24 05:35:26 +000075 }
76
77 /// EmitLoadOfLValue - Given an expression with complex type that represents a
78 /// value l-value, this method emits the address of the l-value, then loads
79 /// and returns the result.
80 Value *EmitLoadOfLValue(const Expr *E) {
Chris Lattner7f02f722007-08-24 05:35:26 +000081 return EmitLoadOfLValue(EmitLValue(E), E->getType());
82 }
83
Chris Lattner9abc84e2007-08-26 16:42:57 +000084 /// EmitConversionToBool - Convert the specified expression value to a
Chris Lattner3420d0d2007-08-26 17:25:57 +000085 /// boolean (i1) truth value. This is equivalent to "Val != 0".
Chris Lattner9abc84e2007-08-26 16:42:57 +000086 Value *EmitConversionToBool(Value *Src, QualType DstTy);
87
Chris Lattner3707b252007-08-26 06:48:56 +000088 /// EmitScalarConversion - Emit a conversion from the specified type to the
89 /// specified destination type, both of which are LLVM scalar types.
Chris Lattner4f1a7b32007-08-26 16:34:22 +000090 Value *EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy);
91
92 /// EmitComplexToScalarConversion - Emit a conversion from the specified
93 /// complex type to the specified destination type, where the destination
94 /// type is an LLVM scalar type.
95 Value *EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src,
96 QualType SrcTy, QualType DstTy);
Mike Stumpdf6b68c2009-02-12 18:29:15 +000097
Chris Lattner7f02f722007-08-24 05:35:26 +000098 //===--------------------------------------------------------------------===//
99 // Visitor Methods
100 //===--------------------------------------------------------------------===//
101
102 Value *VisitStmt(Stmt *S) {
Ted Kremenek7a9d49f2007-12-11 21:27:55 +0000103 S->dump(CGF.getContext().getSourceManager());
Chris Lattner7f02f722007-08-24 05:35:26 +0000104 assert(0 && "Stmt can't have complex result type!");
105 return 0;
106 }
107 Value *VisitExpr(Expr *S);
108 Value *VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr()); }
109
110 // Leaves.
111 Value *VisitIntegerLiteral(const IntegerLiteral *E) {
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000112 return llvm::ConstantInt::get(VMContext, E->getValue());
Chris Lattner7f02f722007-08-24 05:35:26 +0000113 }
114 Value *VisitFloatingLiteral(const FloatingLiteral *E) {
Owen Andersonbc0a2222009-07-27 21:00:51 +0000115 return llvm::ConstantFP::get(VMContext, E->getValue());
Chris Lattner7f02f722007-08-24 05:35:26 +0000116 }
117 Value *VisitCharacterLiteral(const CharacterLiteral *E) {
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000118 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
Chris Lattner7f02f722007-08-24 05:35:26 +0000119 }
Nate Begemane7579b52007-11-15 05:40:03 +0000120 Value *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000121 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
Nate Begemane7579b52007-11-15 05:40:03 +0000122 }
Argyrios Kyrtzidis7267f782008-08-23 19:35:47 +0000123 Value *VisitCXXZeroInitValueExpr(const CXXZeroInitValueExpr *E) {
Owen Andersona1cf15f2009-07-14 23:10:40 +0000124 return VMContext.getNullValue(ConvertType(E->getType()));
Argyrios Kyrtzidis7267f782008-08-23 19:35:47 +0000125 }
Anders Carlsson3f704562008-12-21 22:39:40 +0000126 Value *VisitGNUNullExpr(const GNUNullExpr *E) {
Owen Andersona1cf15f2009-07-14 23:10:40 +0000127 return VMContext.getNullValue(ConvertType(E->getType()));
Anders Carlsson3f704562008-12-21 22:39:40 +0000128 }
Chris Lattner7f02f722007-08-24 05:35:26 +0000129 Value *VisitTypesCompatibleExpr(const TypesCompatibleExpr *E) {
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000130 return llvm::ConstantInt::get(ConvertType(E->getType()),
Steve Naroffec0550f2007-10-15 20:41:53 +0000131 CGF.getContext().typesAreCompatible(
132 E->getArgType1(), E->getArgType2()));
Chris Lattner7f02f722007-08-24 05:35:26 +0000133 }
Sebastian Redl05189992008-11-11 17:56:53 +0000134 Value *VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E);
Daniel Dunbar0ffb1252008-08-04 16:51:22 +0000135 Value *VisitAddrLabelExpr(const AddrLabelExpr *E) {
Daniel Dunbar54d19092008-08-16 01:41:47 +0000136 llvm::Value *V =
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000137 llvm::ConstantInt::get(llvm::Type::Int32Ty,
Daniel Dunbar54d19092008-08-16 01:41:47 +0000138 CGF.GetIDForAddrOfLabel(E->getLabel()));
139
140 return Builder.CreateIntToPtr(V, ConvertType(E->getType()));
Daniel Dunbar0ffb1252008-08-04 16:51:22 +0000141 }
Chris Lattner7f02f722007-08-24 05:35:26 +0000142
143 // l-values.
144 Value *VisitDeclRefExpr(DeclRefExpr *E) {
145 if (const EnumConstantDecl *EC = dyn_cast<EnumConstantDecl>(E->getDecl()))
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000146 return llvm::ConstantInt::get(VMContext, EC->getInitVal());
Chris Lattner7f02f722007-08-24 05:35:26 +0000147 return EmitLoadOfLValue(E);
148 }
Daniel Dunbar9c3fc702008-08-27 06:57:25 +0000149 Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
150 return CGF.EmitObjCSelectorExpr(E);
151 }
152 Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
153 return CGF.EmitObjCProtocolExpr(E);
154 }
155 Value *VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
156 return EmitLoadOfLValue(E);
157 }
Daniel Dunbar0a04d772008-08-23 10:51:21 +0000158 Value *VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000159 return EmitLoadOfLValue(E);
Daniel Dunbar9c3fc702008-08-27 06:57:25 +0000160 }
Fariborz Jahanian43f44702008-11-22 22:30:21 +0000161 Value *VisitObjCKVCRefExpr(ObjCKVCRefExpr *E) {
162 return EmitLoadOfLValue(E);
163 }
Daniel Dunbar9c3fc702008-08-27 06:57:25 +0000164 Value *VisitObjCMessageExpr(ObjCMessageExpr *E) {
165 return CGF.EmitObjCMessageExpr(E).getScalarVal();
Daniel Dunbar0a04d772008-08-23 10:51:21 +0000166 }
167
Chris Lattner7f02f722007-08-24 05:35:26 +0000168 Value *VisitArraySubscriptExpr(ArraySubscriptExpr *E);
Eli Friedmand38617c2008-05-14 19:38:39 +0000169 Value *VisitShuffleVectorExpr(ShuffleVectorExpr *E);
Chris Lattner7f02f722007-08-24 05:35:26 +0000170 Value *VisitMemberExpr(Expr *E) { return EmitLoadOfLValue(E); }
Nate Begeman213541a2008-04-18 23:10:10 +0000171 Value *VisitExtVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); }
Chris Lattnerbe20bb52008-10-26 23:53:12 +0000172 Value *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
173 return EmitLoadOfLValue(E);
174 }
Chris Lattner7f02f722007-08-24 05:35:26 +0000175 Value *VisitStringLiteral(Expr *E) { return EmitLValue(E).getAddress(); }
Chris Lattnereaf2bb82009-02-24 22:18:39 +0000176 Value *VisitObjCEncodeExpr(const ObjCEncodeExpr *E) {
177 return EmitLValue(E).getAddress();
178 }
179
Chris Lattnerd9f69102008-08-10 01:53:14 +0000180 Value *VisitPredefinedExpr(Expr *E) { return EmitLValue(E).getAddress(); }
Devang Patel35634f52007-10-24 17:18:43 +0000181
182 Value *VisitInitListExpr(InitListExpr *E) {
Mike Stump7f79f9b2009-05-29 15:46:01 +0000183 bool Ignore = TestAndClearIgnoreResultAssign();
184 (void)Ignore;
185 assert (Ignore == false && "init list ignored");
Anders Carlsson7019a9e2007-12-05 07:36:10 +0000186 unsigned NumInitElements = E->getNumInits();
187
Douglas Gregora9c87802009-01-29 19:42:23 +0000188 if (E->hadArrayRangeDesignator()) {
189 CGF.ErrorUnsupported(E, "GNU array range designator extension");
190 }
191
Anders Carlsson7019a9e2007-12-05 07:36:10 +0000192 const llvm::VectorType *VType =
Anders Carlssonf6884ac2008-01-29 01:15:48 +0000193 dyn_cast<llvm::VectorType>(ConvertType(E->getType()));
194
195 // We have a scalar in braces. Just use the first element.
196 if (!VType)
197 return Visit(E->getInit(0));
Anders Carlsson7019a9e2007-12-05 07:36:10 +0000198
Anders Carlsson7019a9e2007-12-05 07:36:10 +0000199 unsigned NumVectorElements = VType->getNumElements();
200 const llvm::Type *ElementType = VType->getElementType();
Anders Carlsson7019a9e2007-12-05 07:36:10 +0000201
202 // Emit individual vector element stores.
Owen Andersona1cf15f2009-07-14 23:10:40 +0000203 llvm::Value *V = VMContext.getUndef(VType);
Anders Carlsson7019a9e2007-12-05 07:36:10 +0000204
Anders Carlsson222d2c82007-12-18 02:45:33 +0000205 // Emit initializers
206 unsigned i;
207 for (i = 0; i < NumInitElements; ++i) {
Devang Patela83cc332007-10-24 18:05:48 +0000208 Value *NewV = Visit(E->getInit(i));
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000209 Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, i);
Devang Patela83cc332007-10-24 18:05:48 +0000210 V = Builder.CreateInsertElement(V, NewV, Idx);
Devang Patel35634f52007-10-24 17:18:43 +0000211 }
Anders Carlsson7019a9e2007-12-05 07:36:10 +0000212
213 // Emit remaining default initializers
214 for (/* Do not initialize i*/; i < NumVectorElements; ++i) {
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000215 Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, i);
Owen Andersona1cf15f2009-07-14 23:10:40 +0000216 llvm::Value *NewV = VMContext.getNullValue(ElementType);
Anders Carlsson7019a9e2007-12-05 07:36:10 +0000217 V = Builder.CreateInsertElement(V, NewV, Idx);
218 }
219
Devang Patela83cc332007-10-24 18:05:48 +0000220 return V;
Devang Patel35634f52007-10-24 17:18:43 +0000221 }
Chris Lattner04421082008-04-08 04:40:51 +0000222
Douglas Gregor3498bdb2009-01-29 17:44:32 +0000223 Value *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
Owen Andersona1cf15f2009-07-14 23:10:40 +0000224 return VMContext.getNullValue(ConvertType(E->getType()));
Douglas Gregor3498bdb2009-01-29 17:44:32 +0000225 }
Chris Lattner7f02f722007-08-24 05:35:26 +0000226 Value *VisitImplicitCastExpr(const ImplicitCastExpr *E);
Eli Friedmanc62aad82009-04-20 03:54:15 +0000227 Value *VisitCastExpr(const CastExpr *E) {
228 // Make sure to evaluate VLA bounds now so that we have them for later.
229 if (E->getType()->isVariablyModifiedType())
230 CGF.EmitVLASize(E->getType());
231
Chris Lattner7f02f722007-08-24 05:35:26 +0000232 return EmitCastExpr(E->getSubExpr(), E->getType());
233 }
234 Value *EmitCastExpr(const Expr *E, QualType T);
235
236 Value *VisitCallExpr(const CallExpr *E) {
Anders Carlssone9f2f452009-05-27 03:37:57 +0000237 if (E->getCallReturnType()->isReferenceType())
238 return EmitLoadOfLValue(E);
239
Chris Lattner9b655512007-08-31 22:49:20 +0000240 return CGF.EmitCallExpr(E).getScalarVal();
Chris Lattner7f02f722007-08-24 05:35:26 +0000241 }
Daniel Dunbar8f2926b2008-08-23 03:46:30 +0000242
Chris Lattner33793202007-08-31 22:09:40 +0000243 Value *VisitStmtExpr(const StmtExpr *E);
Mike Stump4e7a1f72009-02-21 20:00:35 +0000244
Mike Stumpa99038c2009-02-28 09:07:16 +0000245 Value *VisitBlockDeclRefExpr(const BlockDeclRefExpr *E);
Chris Lattner33793202007-08-31 22:09:40 +0000246
Chris Lattner7f02f722007-08-24 05:35:26 +0000247 // Unary Operators.
248 Value *VisitPrePostIncDec(const UnaryOperator *E, bool isInc, bool isPre);
249 Value *VisitUnaryPostDec(const UnaryOperator *E) {
250 return VisitPrePostIncDec(E, false, false);
251 }
252 Value *VisitUnaryPostInc(const UnaryOperator *E) {
253 return VisitPrePostIncDec(E, true, false);
254 }
255 Value *VisitUnaryPreDec(const UnaryOperator *E) {
256 return VisitPrePostIncDec(E, false, true);
257 }
258 Value *VisitUnaryPreInc(const UnaryOperator *E) {
259 return VisitPrePostIncDec(E, true, true);
260 }
261 Value *VisitUnaryAddrOf(const UnaryOperator *E) {
262 return EmitLValue(E->getSubExpr()).getAddress();
263 }
264 Value *VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); }
265 Value *VisitUnaryPlus(const UnaryOperator *E) {
Mike Stump7f79f9b2009-05-29 15:46:01 +0000266 // This differs from gcc, though, most likely due to a bug in gcc.
267 TestAndClearIgnoreResultAssign();
Chris Lattner7f02f722007-08-24 05:35:26 +0000268 return Visit(E->getSubExpr());
269 }
270 Value *VisitUnaryMinus (const UnaryOperator *E);
271 Value *VisitUnaryNot (const UnaryOperator *E);
272 Value *VisitUnaryLNot (const UnaryOperator *E);
Chris Lattner46f93d02007-08-24 21:20:17 +0000273 Value *VisitUnaryReal (const UnaryOperator *E);
274 Value *VisitUnaryImag (const UnaryOperator *E);
Chris Lattner7f02f722007-08-24 05:35:26 +0000275 Value *VisitUnaryExtension(const UnaryOperator *E) {
276 return Visit(E->getSubExpr());
277 }
Anders Carlsson5a1deb82008-01-29 15:56:48 +0000278 Value *VisitUnaryOffsetOf(const UnaryOperator *E);
Anders Carlsson5f4307b2009-04-14 16:58:56 +0000279
280 // C++
Chris Lattner04421082008-04-08 04:40:51 +0000281 Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
282 return Visit(DAE->getExpr());
283 }
Anders Carlsson5f4307b2009-04-14 16:58:56 +0000284 Value *VisitCXXThisExpr(CXXThisExpr *TE) {
285 return CGF.LoadCXXThis();
286 }
Anders Carlsson5a1deb82008-01-29 15:56:48 +0000287
Anders Carlsson7f6ad152009-05-19 04:48:36 +0000288 Value *VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) {
Anders Carlsson30824632009-05-31 00:09:15 +0000289 return CGF.EmitCXXExprWithTemporaries(E).getScalarVal();
Anders Carlsson7f6ad152009-05-19 04:48:36 +0000290 }
Anders Carlssona00703d2009-05-31 01:40:14 +0000291 Value *VisitCXXNewExpr(const CXXNewExpr *E) {
292 return CGF.EmitCXXNewExpr(E);
293 }
Anders Carlsson7f6ad152009-05-19 04:48:36 +0000294
Chris Lattner7f02f722007-08-24 05:35:26 +0000295 // Binary Operators.
Chris Lattner7f02f722007-08-24 05:35:26 +0000296 Value *EmitMul(const BinOpInfo &Ops) {
Mike Stump035cf892009-04-02 18:15:54 +0000297 if (CGF.getContext().getLangOptions().OverflowChecking
298 && Ops.Ty->isSignedIntegerType())
Mike Stump2add4732009-04-01 20:28:16 +0000299 return EmitOverflowCheckedBinOp(Ops);
Chris Lattner87415d22009-06-17 06:36:24 +0000300 if (Ops.LHS->getType()->isFPOrFPVector())
301 return Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul");
Chris Lattner7f02f722007-08-24 05:35:26 +0000302 return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
303 }
Mike Stump2add4732009-04-01 20:28:16 +0000304 /// Create a binary op that checks for overflow.
305 /// Currently only supports +, - and *.
306 Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops);
Chris Lattner7f02f722007-08-24 05:35:26 +0000307 Value *EmitDiv(const BinOpInfo &Ops);
308 Value *EmitRem(const BinOpInfo &Ops);
309 Value *EmitAdd(const BinOpInfo &Ops);
310 Value *EmitSub(const BinOpInfo &Ops);
311 Value *EmitShl(const BinOpInfo &Ops);
312 Value *EmitShr(const BinOpInfo &Ops);
313 Value *EmitAnd(const BinOpInfo &Ops) {
314 return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and");
315 }
316 Value *EmitXor(const BinOpInfo &Ops) {
317 return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor");
318 }
319 Value *EmitOr (const BinOpInfo &Ops) {
320 return Builder.CreateOr(Ops.LHS, Ops.RHS, "or");
321 }
322
Chris Lattner1f1ded92007-08-24 21:00:35 +0000323 BinOpInfo EmitBinOps(const BinaryOperator *E);
Chris Lattner3ccf7742007-08-26 21:41:21 +0000324 Value *EmitCompoundAssign(const CompoundAssignOperator *E,
Chris Lattner1f1ded92007-08-24 21:00:35 +0000325 Value *(ScalarExprEmitter::*F)(const BinOpInfo &));
326
327 // Binary operators and binary compound assignment operators.
328#define HANDLEBINOP(OP) \
Chris Lattner3ccf7742007-08-26 21:41:21 +0000329 Value *VisitBin ## OP(const BinaryOperator *E) { \
330 return Emit ## OP(EmitBinOps(E)); \
331 } \
332 Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \
333 return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \
Chris Lattner1f1ded92007-08-24 21:00:35 +0000334 }
335 HANDLEBINOP(Mul);
336 HANDLEBINOP(Div);
337 HANDLEBINOP(Rem);
338 HANDLEBINOP(Add);
Daniel Dunbar8c6f57c2008-08-06 02:00:38 +0000339 HANDLEBINOP(Sub);
Chris Lattner1f1ded92007-08-24 21:00:35 +0000340 HANDLEBINOP(Shl);
341 HANDLEBINOP(Shr);
342 HANDLEBINOP(And);
343 HANDLEBINOP(Xor);
344 HANDLEBINOP(Or);
345#undef HANDLEBINOP
Daniel Dunbar8c6f57c2008-08-06 02:00:38 +0000346
Chris Lattner7f02f722007-08-24 05:35:26 +0000347 // Comparisons.
348 Value *EmitCompare(const BinaryOperator *E, unsigned UICmpOpc,
349 unsigned SICmpOpc, unsigned FCmpOpc);
350#define VISITCOMP(CODE, UI, SI, FP) \
351 Value *VisitBin##CODE(const BinaryOperator *E) { \
352 return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \
353 llvm::FCmpInst::FP); }
354 VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT);
355 VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT);
356 VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE);
357 VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE);
358 VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ);
359 VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE);
360#undef VISITCOMP
361
362 Value *VisitBinAssign (const BinaryOperator *E);
363
364 Value *VisitBinLAnd (const BinaryOperator *E);
365 Value *VisitBinLOr (const BinaryOperator *E);
Chris Lattner7f02f722007-08-24 05:35:26 +0000366 Value *VisitBinComma (const BinaryOperator *E);
367
368 // Other Operators.
Mike Stumpdf6b68c2009-02-12 18:29:15 +0000369 Value *VisitBlockExpr(const BlockExpr *BE);
Chris Lattner7f02f722007-08-24 05:35:26 +0000370 Value *VisitConditionalOperator(const ConditionalOperator *CO);
371 Value *VisitChooseExpr(ChooseExpr *CE);
Anders Carlsson7c50aca2007-10-15 20:28:48 +0000372 Value *VisitVAArgExpr(VAArgExpr *VE);
Chris Lattner7f02f722007-08-24 05:35:26 +0000373 Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) {
374 return CGF.EmitObjCStringLiteral(E);
375 }
376};
377} // end anonymous namespace.
378
379//===----------------------------------------------------------------------===//
380// Utilities
381//===----------------------------------------------------------------------===//
382
Chris Lattner9abc84e2007-08-26 16:42:57 +0000383/// EmitConversionToBool - Convert the specified expression value to a
Chris Lattner3420d0d2007-08-26 17:25:57 +0000384/// boolean (i1) truth value. This is equivalent to "Val != 0".
Chris Lattner9abc84e2007-08-26 16:42:57 +0000385Value *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) {
386 assert(SrcType->isCanonical() && "EmitScalarConversion strips typedefs");
387
388 if (SrcType->isRealFloatingType()) {
389 // Compare against 0.0 for fp scalars.
Owen Andersona1cf15f2009-07-14 23:10:40 +0000390 llvm::Value *Zero = VMContext.getNullValue(Src->getType());
Chris Lattner9abc84e2007-08-26 16:42:57 +0000391 return Builder.CreateFCmpUNE(Src, Zero, "tobool");
392 }
393
Daniel Dunbard1d66bc2008-08-25 10:38:11 +0000394 assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) &&
Chris Lattner9abc84e2007-08-26 16:42:57 +0000395 "Unknown scalar type to convert");
396
397 // Because of the type rules of C, we often end up computing a logical value,
398 // then zero extending it to int, then wanting it as a logical value again.
399 // Optimize this common case.
400 if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(Src)) {
401 if (ZI->getOperand(0)->getType() == llvm::Type::Int1Ty) {
402 Value *Result = ZI->getOperand(0);
Eli Friedman356916e2008-01-29 18:13:51 +0000403 // If there aren't any more uses, zap the instruction to save space.
404 // Note that there can be more uses, for example if this
405 // is the result of an assignment.
406 if (ZI->use_empty())
407 ZI->eraseFromParent();
Chris Lattner9abc84e2007-08-26 16:42:57 +0000408 return Result;
409 }
410 }
411
412 // Compare against an integer or pointer null.
Owen Andersona1cf15f2009-07-14 23:10:40 +0000413 llvm::Value *Zero = VMContext.getNullValue(Src->getType());
Chris Lattner9abc84e2007-08-26 16:42:57 +0000414 return Builder.CreateICmpNE(Src, Zero, "tobool");
415}
416
Chris Lattner3707b252007-08-26 06:48:56 +0000417/// EmitScalarConversion - Emit a conversion from the specified type to the
418/// specified destination type, both of which are LLVM scalar types.
Chris Lattner4f1a7b32007-08-26 16:34:22 +0000419Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
420 QualType DstType) {
Chris Lattner96196622008-07-26 22:37:01 +0000421 SrcType = CGF.getContext().getCanonicalType(SrcType);
422 DstType = CGF.getContext().getCanonicalType(DstType);
Chris Lattner3707b252007-08-26 06:48:56 +0000423 if (SrcType == DstType) return Src;
Chris Lattnercf289082007-08-26 07:21:11 +0000424
425 if (DstType->isVoidType()) return 0;
Chris Lattner3707b252007-08-26 06:48:56 +0000426
427 // Handle conversions to bool first, they are special: comparisons against 0.
Chris Lattnered70f0a2007-08-26 16:52:28 +0000428 if (DstType->isBooleanType())
429 return EmitConversionToBool(Src, SrcType);
Chris Lattner3707b252007-08-26 06:48:56 +0000430
431 const llvm::Type *DstTy = ConvertType(DstType);
432
433 // Ignore conversions like int -> uint.
434 if (Src->getType() == DstTy)
435 return Src;
436
Daniel Dunbar270cc662008-08-25 09:51:32 +0000437 // Handle pointer conversions next: pointers can only be converted
438 // to/from other pointers and integers. Check for pointer types in
439 // terms of LLVM, as some native types (like Obj-C id) may map to a
440 // pointer type.
441 if (isa<llvm::PointerType>(DstTy)) {
Chris Lattner3707b252007-08-26 06:48:56 +0000442 // The source value may be an integer, or a pointer.
Fariborz Jahanianfa9f8b42009-07-28 22:00:58 +0000443 if (isa<llvm::PointerType>(Src->getType())) {
444 // Some heavy lifting for derived to base conversion.
Fariborz Jahaniana91d6a62009-07-29 00:44:13 +0000445 if (const CXXRecordDecl *ClassDecl =
446 SrcType->getCXXRecordDeclForPointerType())
447 if (const CXXRecordDecl *BaseClassDecl =
448 DstType->getCXXRecordDeclForPointerType())
449 Src = CGF.AddressCXXOfBaseClass(Src, ClassDecl, BaseClassDecl);
Chris Lattner3707b252007-08-26 06:48:56 +0000450 return Builder.CreateBitCast(Src, DstTy, "conv");
Fariborz Jahanianfa9f8b42009-07-28 22:00:58 +0000451 }
Chris Lattner3707b252007-08-26 06:48:56 +0000452 assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?");
Eli Friedman25615422009-03-04 04:02:35 +0000453 // First, convert to the correct width so that we control the kind of
454 // extension.
Owen Andersona1cf15f2009-07-14 23:10:40 +0000455 const llvm::Type *MiddleTy = VMContext.getIntegerType(CGF.LLVMPointerWidth);
Eli Friedman25615422009-03-04 04:02:35 +0000456 bool InputSigned = SrcType->isSignedIntegerType();
457 llvm::Value* IntResult =
458 Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv");
459 // Then, cast to pointer.
460 return Builder.CreateIntToPtr(IntResult, DstTy, "conv");
Chris Lattner3707b252007-08-26 06:48:56 +0000461 }
462
Daniel Dunbar270cc662008-08-25 09:51:32 +0000463 if (isa<llvm::PointerType>(Src->getType())) {
Chris Lattner3707b252007-08-26 06:48:56 +0000464 // Must be an ptr to int cast.
465 assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?");
Anders Carlsson50b5a302007-10-31 23:18:02 +0000466 return Builder.CreatePtrToInt(Src, DstTy, "conv");
Chris Lattner3707b252007-08-26 06:48:56 +0000467 }
468
Nate Begeman213541a2008-04-18 23:10:10 +0000469 // A scalar can be splatted to an extended vector of the same element type
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000470 if (DstType->isExtVectorType() && !isa<VectorType>(SrcType)) {
471 // Cast the scalar to element type
472 QualType EltTy = DstType->getAsExtVectorType()->getElementType();
473 llvm::Value *Elt = EmitScalarConversion(Src, SrcType, EltTy);
474
475 // Insert the element in element zero of an undef vector
Owen Andersona1cf15f2009-07-14 23:10:40 +0000476 llvm::Value *UnV = VMContext.getUndef(DstTy);
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000477 llvm::Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000478 UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp");
479
480 // Splat the element across to all elements
481 llvm::SmallVector<llvm::Constant*, 16> Args;
482 unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements();
483 for (unsigned i = 0; i < NumElements; i++)
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000484 Args.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, 0));
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000485
Owen Anderson4a289322009-07-28 21:22:35 +0000486 llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements);
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000487 llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat");
488 return Yay;
489 }
Nate Begeman4119d1a2007-12-30 02:59:45 +0000490
Chris Lattner3b1ae002008-02-02 04:51:41 +0000491 // Allow bitcast from vector to integer/fp of the same size.
Anders Carlsson7019a9e2007-12-05 07:36:10 +0000492 if (isa<llvm::VectorType>(Src->getType()) ||
Chris Lattner3b1ae002008-02-02 04:51:41 +0000493 isa<llvm::VectorType>(DstTy))
Anders Carlsson7019a9e2007-12-05 07:36:10 +0000494 return Builder.CreateBitCast(Src, DstTy, "conv");
Anders Carlsson7019a9e2007-12-05 07:36:10 +0000495
Chris Lattner3707b252007-08-26 06:48:56 +0000496 // Finally, we have the arithmetic types: real int/float.
497 if (isa<llvm::IntegerType>(Src->getType())) {
498 bool InputSigned = SrcType->isSignedIntegerType();
Anders Carlssonb5ce0972007-12-26 18:20:19 +0000499 if (isa<llvm::IntegerType>(DstTy))
500 return Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
501 else if (InputSigned)
502 return Builder.CreateSIToFP(Src, DstTy, "conv");
503 else
504 return Builder.CreateUIToFP(Src, DstTy, "conv");
Chris Lattner3707b252007-08-26 06:48:56 +0000505 }
506
507 assert(Src->getType()->isFloatingPoint() && "Unknown real conversion");
508 if (isa<llvm::IntegerType>(DstTy)) {
Anders Carlssonb5ce0972007-12-26 18:20:19 +0000509 if (DstType->isSignedIntegerType())
510 return Builder.CreateFPToSI(Src, DstTy, "conv");
511 else
512 return Builder.CreateFPToUI(Src, DstTy, "conv");
Chris Lattner3707b252007-08-26 06:48:56 +0000513 }
514
515 assert(DstTy->isFloatingPoint() && "Unknown real conversion");
Anders Carlssonb5ce0972007-12-26 18:20:19 +0000516 if (DstTy->getTypeID() < Src->getType()->getTypeID())
517 return Builder.CreateFPTrunc(Src, DstTy, "conv");
518 else
519 return Builder.CreateFPExt(Src, DstTy, "conv");
Chris Lattner3707b252007-08-26 06:48:56 +0000520}
521
Chris Lattner4f1a7b32007-08-26 16:34:22 +0000522/// EmitComplexToScalarConversion - Emit a conversion from the specified
523/// complex type to the specified destination type, where the destination
524/// type is an LLVM scalar type.
525Value *ScalarExprEmitter::
526EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src,
527 QualType SrcTy, QualType DstTy) {
Chris Lattnered70f0a2007-08-26 16:52:28 +0000528 // Get the source element type.
Chris Lattner96196622008-07-26 22:37:01 +0000529 SrcTy = SrcTy->getAsComplexType()->getElementType();
Chris Lattnered70f0a2007-08-26 16:52:28 +0000530
531 // Handle conversions to bool first, they are special: comparisons against 0.
532 if (DstTy->isBooleanType()) {
533 // Complex != 0 -> (Real != 0) | (Imag != 0)
534 Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy);
535 Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy);
536 return Builder.CreateOr(Src.first, Src.second, "tobool");
537 }
538
Chris Lattner4f1a7b32007-08-26 16:34:22 +0000539 // C99 6.3.1.7p2: "When a value of complex type is converted to a real type,
540 // the imaginary part of the complex value is discarded and the value of the
541 // real part is converted according to the conversion rules for the
542 // corresponding real type.
Chris Lattner4f1a7b32007-08-26 16:34:22 +0000543 return EmitScalarConversion(Src.first, SrcTy, DstTy);
544}
545
546
Chris Lattner7f02f722007-08-24 05:35:26 +0000547//===----------------------------------------------------------------------===//
548// Visitor Methods
549//===----------------------------------------------------------------------===//
550
551Value *ScalarExprEmitter::VisitExpr(Expr *E) {
Daniel Dunbar488e9932008-08-16 00:56:44 +0000552 CGF.ErrorUnsupported(E, "scalar expression");
Chris Lattner7f02f722007-08-24 05:35:26 +0000553 if (E->getType()->isVoidType())
554 return 0;
Owen Andersona1cf15f2009-07-14 23:10:40 +0000555 return VMContext.getUndef(CGF.ConvertType(E->getType()));
Chris Lattner7f02f722007-08-24 05:35:26 +0000556}
557
Eli Friedmand38617c2008-05-14 19:38:39 +0000558Value *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
559 llvm::SmallVector<llvm::Constant*, 32> indices;
560 for (unsigned i = 2; i < E->getNumSubExprs(); i++) {
561 indices.push_back(cast<llvm::Constant>(CGF.EmitScalarExpr(E->getExpr(i))));
562 }
563 Value* V1 = CGF.EmitScalarExpr(E->getExpr(0));
564 Value* V2 = CGF.EmitScalarExpr(E->getExpr(1));
Owen Anderson4a289322009-07-28 21:22:35 +0000565 Value* SV = llvm::ConstantVector::get(indices.begin(), indices.size());
Eli Friedmand38617c2008-05-14 19:38:39 +0000566 return Builder.CreateShuffleVector(V1, V2, SV, "shuffle");
567}
568
Chris Lattner7f02f722007-08-24 05:35:26 +0000569Value *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
Mike Stump7f79f9b2009-05-29 15:46:01 +0000570 TestAndClearIgnoreResultAssign();
571
Chris Lattner7f02f722007-08-24 05:35:26 +0000572 // Emit subscript expressions in rvalue context's. For most cases, this just
573 // loads the lvalue formed by the subscript expr. However, we have to be
574 // careful, because the base of a vector subscript is occasionally an rvalue,
575 // so we can't get it as an lvalue.
576 if (!E->getBase()->getType()->isVectorType())
577 return EmitLoadOfLValue(E);
578
579 // Handle the vector case. The base must be a vector, the index must be an
580 // integer value.
581 Value *Base = Visit(E->getBase());
582 Value *Idx = Visit(E->getIdx());
Eli Friedmandaa24a22009-03-28 02:45:41 +0000583 bool IdxSigned = E->getIdx()->getType()->isSignedIntegerType();
Eli Friedman515ff5a2009-03-28 03:27:06 +0000584 Idx = Builder.CreateIntCast(Idx, llvm::Type::Int32Ty, IdxSigned,
585 "vecidxcast");
Chris Lattner7f02f722007-08-24 05:35:26 +0000586 return Builder.CreateExtractElement(Base, Idx, "vecext");
587}
588
589/// VisitImplicitCastExpr - Implicit casts are the same as normal casts, but
590/// also handle things like function to pointer-to-function decay, and array to
591/// pointer decay.
592Value *ScalarExprEmitter::VisitImplicitCastExpr(const ImplicitCastExpr *E) {
593 const Expr *Op = E->getSubExpr();
594
595 // If this is due to array->pointer conversion, emit the array expression as
596 // an l-value.
597 if (Op->getType()->isArrayType()) {
Chris Lattner4f1a7b32007-08-26 16:34:22 +0000598 Value *V = EmitLValue(Op).getAddress(); // Bitfields can't be arrays.
Eli Friedman8f39f5e2008-12-20 23:11:59 +0000599
Eli Friedmandaa24a22009-03-28 02:45:41 +0000600 // Note that VLA pointers are always decayed, so we don't need to do
601 // anything here.
Eli Friedman8f39f5e2008-12-20 23:11:59 +0000602 if (!Op->getType()->isVariableArrayType()) {
603 assert(isa<llvm::PointerType>(V->getType()) && "Expected pointer");
604 assert(isa<llvm::ArrayType>(cast<llvm::PointerType>(V->getType())
605 ->getElementType()) &&
606 "Expected pointer to array");
607 V = Builder.CreateStructGEP(V, 0, "arraydecay");
Daniel Dunbar662174c82008-08-29 17:28:43 +0000608 }
Chris Lattnera9e63722007-12-12 04:13:20 +0000609
610 // The resultant pointer type can be implicitly casted to other pointer
Chris Lattnerf31627f2008-07-23 06:31:27 +0000611 // types as well (e.g. void*) and can be implicitly converted to integer.
612 const llvm::Type *DestTy = ConvertType(E->getType());
613 if (V->getType() != DestTy) {
614 if (isa<llvm::PointerType>(DestTy))
615 V = Builder.CreateBitCast(V, DestTy, "ptrconv");
616 else {
617 assert(isa<llvm::IntegerType>(DestTy) && "Unknown array decay");
618 V = Builder.CreatePtrToInt(V, DestTy, "ptrconv");
619 }
620 }
Chris Lattnera9e63722007-12-12 04:13:20 +0000621 return V;
Chris Lattner7f02f722007-08-24 05:35:26 +0000622 }
Eli Friedmandaa24a22009-03-28 02:45:41 +0000623
Chris Lattner7f02f722007-08-24 05:35:26 +0000624 return EmitCastExpr(Op, E->getType());
625}
626
627
628// VisitCastExpr - Emit code for an explicit or implicit cast. Implicit casts
629// have to handle a more broad range of conversions than explicit casts, as they
630// handle things like function to ptr-to-function decay etc.
631Value *ScalarExprEmitter::EmitCastExpr(const Expr *E, QualType DestTy) {
Mike Stump7f79f9b2009-05-29 15:46:01 +0000632 if (!DestTy->isVoidType())
633 TestAndClearIgnoreResultAssign();
634
Chris Lattner58a2e942007-08-26 07:26:12 +0000635 // Handle cases where the source is an non-complex type.
Chris Lattner19a1d7c2008-02-16 23:55:16 +0000636
637 if (!CGF.hasAggregateLLVMType(E->getType())) {
Chris Lattner3707b252007-08-26 06:48:56 +0000638 Value *Src = Visit(const_cast<Expr*>(E));
639
Chris Lattner3707b252007-08-26 06:48:56 +0000640 // Use EmitScalarConversion to perform the conversion.
641 return EmitScalarConversion(Src, E->getType(), DestTy);
642 }
Chris Lattner19a1d7c2008-02-16 23:55:16 +0000643
Chris Lattner9b2dc282008-04-04 16:54:41 +0000644 if (E->getType()->isAnyComplexType()) {
Chris Lattner19a1d7c2008-02-16 23:55:16 +0000645 // Handle cases where the source is a complex type.
Mike Stump7f79f9b2009-05-29 15:46:01 +0000646 bool IgnoreImag = true;
647 bool IgnoreImagAssign = true;
648 bool IgnoreReal = IgnoreResultAssign;
649 bool IgnoreRealAssign = IgnoreResultAssign;
650 if (DestTy->isBooleanType())
651 IgnoreImagAssign = IgnoreImag = false;
652 else if (DestTy->isVoidType()) {
653 IgnoreReal = IgnoreImag = false;
654 IgnoreRealAssign = IgnoreImagAssign = true;
655 }
656 CodeGenFunction::ComplexPairTy V
657 = CGF.EmitComplexExpr(E, IgnoreReal, IgnoreImag, IgnoreRealAssign,
658 IgnoreImagAssign);
659 return EmitComplexToScalarConversion(V, E->getType(), DestTy);
Chris Lattner19a1d7c2008-02-16 23:55:16 +0000660 }
Chris Lattner10b00cf2007-08-26 07:16:41 +0000661
Chris Lattner19a1d7c2008-02-16 23:55:16 +0000662 // Okay, this is a cast from an aggregate. It must be a cast to void. Just
663 // evaluate the result and return.
Mike Stump7f79f9b2009-05-29 15:46:01 +0000664 CGF.EmitAggExpr(E, 0, false, true);
Chris Lattner19a1d7c2008-02-16 23:55:16 +0000665 return 0;
Chris Lattner7f02f722007-08-24 05:35:26 +0000666}
667
Chris Lattner33793202007-08-31 22:09:40 +0000668Value *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) {
Chris Lattner91d723d2008-07-26 20:23:23 +0000669 return CGF.EmitCompoundStmt(*E->getSubStmt(),
670 !E->getType()->isVoidType()).getScalarVal();
Chris Lattner33793202007-08-31 22:09:40 +0000671}
672
Mike Stumpa99038c2009-02-28 09:07:16 +0000673Value *ScalarExprEmitter::VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) {
674 return Builder.CreateLoad(CGF.GetAddrOfBlockDecl(E), false, "tmp");
Mike Stump4e7a1f72009-02-21 20:00:35 +0000675}
Chris Lattner33793202007-08-31 22:09:40 +0000676
Chris Lattner7f02f722007-08-24 05:35:26 +0000677//===----------------------------------------------------------------------===//
678// Unary Operators
679//===----------------------------------------------------------------------===//
680
681Value *ScalarExprEmitter::VisitPrePostIncDec(const UnaryOperator *E,
Chris Lattnerdfce2a52007-08-24 16:24:49 +0000682 bool isInc, bool isPre) {
Chris Lattner7f02f722007-08-24 05:35:26 +0000683 LValue LV = EmitLValue(E->getSubExpr());
Eli Friedmanf52bbeb2009-03-23 03:00:06 +0000684 QualType ValTy = E->getSubExpr()->getType();
685 Value *InVal = CGF.EmitLoadOfLValue(LV, ValTy).getScalarVal();
Chris Lattner7f02f722007-08-24 05:35:26 +0000686
687 int AmountVal = isInc ? 1 : -1;
Eli Friedmandaa24a22009-03-28 02:45:41 +0000688
689 if (ValTy->isPointerType() &&
Ted Kremenek35366a62009-07-17 17:50:17 +0000690 ValTy->getAsPointerType()->isVariableArrayType()) {
Eli Friedmandaa24a22009-03-28 02:45:41 +0000691 // The amount of the addition/subtraction needs to account for the VLA size
692 CGF.ErrorUnsupported(E, "VLA pointer inc/dec");
693 }
694
Chris Lattner7f02f722007-08-24 05:35:26 +0000695 Value *NextVal;
Chris Lattner8cc9d082009-03-18 04:25:13 +0000696 if (const llvm::PointerType *PT =
697 dyn_cast<llvm::PointerType>(InVal->getType())) {
Owen Andersona1cf15f2009-07-14 23:10:40 +0000698 llvm::Constant *Inc =
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000699 llvm::ConstantInt::get(llvm::Type::Int32Ty, AmountVal);
Chris Lattner8cc9d082009-03-18 04:25:13 +0000700 if (!isa<llvm::FunctionType>(PT->getElementType())) {
Fariborz Jahanian62a11a72009-07-16 22:04:59 +0000701 QualType PTEE = ValTy->getPointeeType();
702 if (const ObjCInterfaceType *OIT =
703 dyn_cast<ObjCInterfaceType>(PTEE)) {
704 // Handle interface types, which are not represented with a concrete type.
705 int size = CGF.getContext().getTypeSize(OIT) / 8;
706 if (!isInc)
707 size = -size;
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000708 Inc = llvm::ConstantInt::get(Inc->getType(), size);
Fariborz Jahanian62a11a72009-07-16 22:04:59 +0000709 const llvm::Type *i8Ty =
710 VMContext.getPointerTypeUnqual(llvm::Type::Int8Ty);
711 InVal = Builder.CreateBitCast(InVal, i8Ty);
712 NextVal = Builder.CreateGEP(InVal, Inc, "add.ptr");
713 llvm::Value *lhs = LV.getAddress();
714 lhs = Builder.CreateBitCast(lhs, VMContext.getPointerTypeUnqual(i8Ty));
715 LV = LValue::MakeAddr(lhs, ValTy.getCVRQualifiers(),
716 CGF.getContext().getObjCGCAttrKind(ValTy));
717 }
718 else
719 NextVal = Builder.CreateGEP(InVal, Inc, "ptrincdec");
Chris Lattner8cc9d082009-03-18 04:25:13 +0000720 } else {
Owen Andersona1cf15f2009-07-14 23:10:40 +0000721 const llvm::Type *i8Ty =
722 VMContext.getPointerTypeUnqual(llvm::Type::Int8Ty);
Chris Lattner8cc9d082009-03-18 04:25:13 +0000723 NextVal = Builder.CreateBitCast(InVal, i8Ty, "tmp");
724 NextVal = Builder.CreateGEP(NextVal, Inc, "ptrincdec");
725 NextVal = Builder.CreateBitCast(NextVal, InVal->getType());
726 }
Chris Lattnerdb3bd4b2009-02-11 07:40:06 +0000727 } else if (InVal->getType() == llvm::Type::Int1Ty && isInc) {
728 // Bool++ is an interesting case, due to promotion rules, we get:
729 // Bool++ -> Bool = Bool+1 -> Bool = (int)Bool+1 ->
730 // Bool = ((int)Bool+1) != 0
731 // An interesting aspect of this is that increment is always true.
732 // Decrement does not have this property.
Owen Anderson4cd16082009-07-21 18:06:41 +0000733 NextVal = VMContext.getTrue();
Chris Lattner87415d22009-06-17 06:36:24 +0000734 } else if (isa<llvm::IntegerType>(InVal->getType())) {
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000735 NextVal = llvm::ConstantInt::get(InVal->getType(), AmountVal);
Chris Lattner87415d22009-06-17 06:36:24 +0000736 NextVal = Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec");
Chris Lattnere936cc82007-08-26 05:10:16 +0000737 } else {
738 // Add the inc/dec to the real part.
Chris Lattner87415d22009-06-17 06:36:24 +0000739 if (InVal->getType() == llvm::Type::FloatTy)
Devang Patele9b8c0a2007-10-30 20:59:40 +0000740 NextVal =
Owen Andersonbc0a2222009-07-27 21:00:51 +0000741 llvm::ConstantFP::get(VMContext,
742 llvm::APFloat(static_cast<float>(AmountVal)));
Chris Lattner25ddea72008-04-20 00:50:39 +0000743 else if (InVal->getType() == llvm::Type::DoubleTy)
Devang Patele9b8c0a2007-10-30 20:59:40 +0000744 NextVal =
Owen Andersonbc0a2222009-07-27 21:00:51 +0000745 llvm::ConstantFP::get(VMContext,
746 llvm::APFloat(static_cast<double>(AmountVal)));
Chris Lattner25ddea72008-04-20 00:50:39 +0000747 else {
748 llvm::APFloat F(static_cast<float>(AmountVal));
Dale Johannesenee5a7002008-10-09 23:02:32 +0000749 bool ignored;
750 F.convert(CGF.Target.getLongDoubleFormat(), llvm::APFloat::rmTowardZero,
751 &ignored);
Owen Andersonbc0a2222009-07-27 21:00:51 +0000752 NextVal = llvm::ConstantFP::get(VMContext, F);
Chris Lattnerca2617c2007-09-13 06:19:18 +0000753 }
Chris Lattner87415d22009-06-17 06:36:24 +0000754 NextVal = Builder.CreateFAdd(InVal, NextVal, isInc ? "inc" : "dec");
Chris Lattnere936cc82007-08-26 05:10:16 +0000755 }
Chris Lattner7f02f722007-08-24 05:35:26 +0000756
757 // Store the updated result through the lvalue.
Eli Friedmanf52bbeb2009-03-23 03:00:06 +0000758 if (LV.isBitfield())
759 CGF.EmitStoreThroughBitfieldLValue(RValue::get(NextVal), LV, ValTy,
760 &NextVal);
761 else
762 CGF.EmitStoreThroughLValue(RValue::get(NextVal), LV, ValTy);
Chris Lattner7f02f722007-08-24 05:35:26 +0000763
764 // If this is a postinc, return the value read from memory, otherwise use the
765 // updated value.
766 return isPre ? NextVal : InVal;
767}
768
769
770Value *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) {
Mike Stump7f79f9b2009-05-29 15:46:01 +0000771 TestAndClearIgnoreResultAssign();
Chris Lattner7f02f722007-08-24 05:35:26 +0000772 Value *Op = Visit(E->getSubExpr());
Chris Lattner87415d22009-06-17 06:36:24 +0000773 if (Op->getType()->isFPOrFPVector())
774 return Builder.CreateFNeg(Op, "neg");
Chris Lattner7f02f722007-08-24 05:35:26 +0000775 return Builder.CreateNeg(Op, "neg");
776}
777
778Value *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
Mike Stump7f79f9b2009-05-29 15:46:01 +0000779 TestAndClearIgnoreResultAssign();
Chris Lattner7f02f722007-08-24 05:35:26 +0000780 Value *Op = Visit(E->getSubExpr());
781 return Builder.CreateNot(Op, "neg");
782}
783
784Value *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) {
785 // Compare operand to zero.
786 Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr());
787
788 // Invert value.
789 // TODO: Could dynamically modify easy computations here. For example, if
790 // the operand is an icmp ne, turn into icmp eq.
791 BoolVal = Builder.CreateNot(BoolVal, "lnot");
792
Anders Carlsson9f84d882009-05-19 18:44:53 +0000793 // ZExt result to the expr type.
794 return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext");
Chris Lattner7f02f722007-08-24 05:35:26 +0000795}
796
Sebastian Redl05189992008-11-11 17:56:53 +0000797/// VisitSizeOfAlignOfExpr - Return the size or alignment of the type of
798/// argument of the sizeof expression as an integer.
799Value *
800ScalarExprEmitter::VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) {
Sebastian Redl05189992008-11-11 17:56:53 +0000801 QualType TypeToSize = E->getTypeOfArgument();
Eli Friedmanf2da9df2009-01-24 22:19:05 +0000802 if (E->isSizeOf()) {
803 if (const VariableArrayType *VAT =
804 CGF.getContext().getAsVariableArrayType(TypeToSize)) {
805 if (E->isArgumentType()) {
806 // sizeof(type) - make sure to emit the VLA size.
807 CGF.EmitVLASize(TypeToSize);
Eli Friedman8f426fa2009-04-20 03:21:44 +0000808 } else {
809 // C99 6.5.3.4p2: If the argument is an expression of type
810 // VLA, it is evaluated.
811 CGF.EmitAnyExpr(E->getArgumentExpr());
Eli Friedmanf2da9df2009-01-24 22:19:05 +0000812 }
Anders Carlsson6cd586d2009-01-30 16:41:04 +0000813
Anders Carlsson96f21472009-02-05 19:43:10 +0000814 return CGF.GetVLASize(VAT);
Anders Carlssonb50525b2008-12-21 03:33:21 +0000815 }
Anders Carlsson5d463152008-12-12 07:38:43 +0000816 }
Eli Friedmanf2da9df2009-01-24 22:19:05 +0000817
818 // If this isn't sizeof(vla), the result must be constant; use the
819 // constant folding logic so we don't have to duplicate it here.
820 Expr::EvalResult Result;
821 E->Evaluate(Result, CGF.getContext());
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000822 return llvm::ConstantInt::get(VMContext, Result.Val.getInt());
Chris Lattner7f02f722007-08-24 05:35:26 +0000823}
824
Chris Lattner46f93d02007-08-24 21:20:17 +0000825Value *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) {
826 Expr *Op = E->getSubExpr();
Chris Lattner9b2dc282008-04-04 16:54:41 +0000827 if (Op->getType()->isAnyComplexType())
Mike Stump7f79f9b2009-05-29 15:46:01 +0000828 return CGF.EmitComplexExpr(Op, false, true, false, true).first;
Chris Lattner46f93d02007-08-24 21:20:17 +0000829 return Visit(Op);
830}
831Value *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) {
832 Expr *Op = E->getSubExpr();
Chris Lattner9b2dc282008-04-04 16:54:41 +0000833 if (Op->getType()->isAnyComplexType())
Mike Stump7f79f9b2009-05-29 15:46:01 +0000834 return CGF.EmitComplexExpr(Op, true, false, true, false).second;
Chris Lattner36f84062007-08-26 05:29:21 +0000835
Mike Stump7f79f9b2009-05-29 15:46:01 +0000836 // __imag on a scalar returns zero. Emit the subexpr to ensure side
837 // effects are evaluated, but not the actual value.
838 if (E->isLvalue(CGF.getContext()) == Expr::LV_Valid)
839 CGF.EmitLValue(Op);
840 else
841 CGF.EmitScalarExpr(Op, true);
Owen Andersona1cf15f2009-07-14 23:10:40 +0000842 return VMContext.getNullValue(ConvertType(E->getType()));
Chris Lattner46f93d02007-08-24 21:20:17 +0000843}
844
Anders Carlsson5a1deb82008-01-29 15:56:48 +0000845Value *ScalarExprEmitter::VisitUnaryOffsetOf(const UnaryOperator *E)
846{
Eli Friedman35183ac2009-02-27 06:44:11 +0000847 Value* ResultAsPtr = EmitLValue(E->getSubExpr()).getAddress();
Eli Friedman769e4112009-01-24 22:38:55 +0000848 const llvm::Type* ResultType = ConvertType(E->getType());
Eli Friedman35183ac2009-02-27 06:44:11 +0000849 return Builder.CreatePtrToInt(ResultAsPtr, ResultType, "offsetof");
Anders Carlsson5a1deb82008-01-29 15:56:48 +0000850}
Chris Lattner46f93d02007-08-24 21:20:17 +0000851
Chris Lattner7f02f722007-08-24 05:35:26 +0000852//===----------------------------------------------------------------------===//
853// Binary Operators
854//===----------------------------------------------------------------------===//
855
856BinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) {
Mike Stump7f79f9b2009-05-29 15:46:01 +0000857 TestAndClearIgnoreResultAssign();
Chris Lattner7f02f722007-08-24 05:35:26 +0000858 BinOpInfo Result;
859 Result.LHS = Visit(E->getLHS());
860 Result.RHS = Visit(E->getRHS());
Chris Lattner1f1ded92007-08-24 21:00:35 +0000861 Result.Ty = E->getType();
Chris Lattner7f02f722007-08-24 05:35:26 +0000862 Result.E = E;
863 return Result;
864}
865
Chris Lattner3ccf7742007-08-26 21:41:21 +0000866Value *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E,
Chris Lattner1f1ded92007-08-24 21:00:35 +0000867 Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) {
Mike Stump7f79f9b2009-05-29 15:46:01 +0000868 bool Ignore = TestAndClearIgnoreResultAssign();
Chris Lattner1f1ded92007-08-24 21:00:35 +0000869 QualType LHSTy = E->getLHS()->getType(), RHSTy = E->getRHS()->getType();
870
871 BinOpInfo OpInfo;
872
Eli Friedmanab3a8522009-03-28 01:22:36 +0000873 if (E->getComputationResultType()->isAnyComplexType()) {
Eli Friedmandaa24a22009-03-28 02:45:41 +0000874 // This needs to go through the complex expression emitter, but
Eli Friedmanab3a8522009-03-28 01:22:36 +0000875 // it's a tad complicated to do that... I'm leaving it out for now.
876 // (Note that we do actually need the imaginary part of the RHS for
877 // multiplication and division.)
878 CGF.ErrorUnsupported(E, "complex compound assignment");
Owen Andersona1cf15f2009-07-14 23:10:40 +0000879 return VMContext.getUndef(CGF.ConvertType(E->getType()));
Eli Friedmanab3a8522009-03-28 01:22:36 +0000880 }
881
Mike Stumpcc0442f2009-05-22 19:07:20 +0000882 // Emit the RHS first. __block variables need to have the rhs evaluated
883 // first, plus this should improve codegen a little.
884 OpInfo.RHS = Visit(E->getRHS());
885 OpInfo.Ty = E->getComputationResultType();
886 OpInfo.E = E;
Eli Friedmanab3a8522009-03-28 01:22:36 +0000887 // Load/convert the LHS.
Chris Lattner1f1ded92007-08-24 21:00:35 +0000888 LValue LHSLV = EmitLValue(E->getLHS());
889 OpInfo.LHS = EmitLoadOfLValue(LHSLV, LHSTy);
Eli Friedmanab3a8522009-03-28 01:22:36 +0000890 OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy,
891 E->getComputationLHSType());
Chris Lattner1f1ded92007-08-24 21:00:35 +0000892
893 // Expand the binary operator.
894 Value *Result = (this->*Func)(OpInfo);
895
Daniel Dunbar8c6f57c2008-08-06 02:00:38 +0000896 // Convert the result back to the LHS type.
Eli Friedmanab3a8522009-03-28 01:22:36 +0000897 Result = EmitScalarConversion(Result, E->getComputationResultType(), LHSTy);
898
Daniel Dunbared3849b2008-11-19 09:36:46 +0000899 // Store the result value into the LHS lvalue. Bit-fields are
Daniel Dunbar371d16f2008-11-19 11:54:05 +0000900 // handled specially because the result is altered by the store,
901 // i.e., [C99 6.5.16p1] 'An assignment expression has the value of
902 // the left operand after the assignment...'.
Mike Stump7f79f9b2009-05-29 15:46:01 +0000903 if (LHSLV.isBitfield()) {
904 if (!LHSLV.isVolatileQualified()) {
905 CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, LHSTy,
906 &Result);
907 return Result;
908 } else
909 CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, LHSTy);
910 } else
Daniel Dunbared3849b2008-11-19 09:36:46 +0000911 CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV, LHSTy);
Mike Stump7f79f9b2009-05-29 15:46:01 +0000912 if (Ignore)
913 return 0;
914 return EmitLoadOfLValue(LHSLV, E->getType());
Chris Lattner1f1ded92007-08-24 21:00:35 +0000915}
916
917
Chris Lattner7f02f722007-08-24 05:35:26 +0000918Value *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) {
Nate Begemanb3ab8dc2007-12-30 01:28:16 +0000919 if (Ops.LHS->getType()->isFPOrFPVector())
Chris Lattner7f02f722007-08-24 05:35:26 +0000920 return Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div");
Chris Lattner1f1ded92007-08-24 21:00:35 +0000921 else if (Ops.Ty->isUnsignedIntegerType())
Chris Lattner7f02f722007-08-24 05:35:26 +0000922 return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div");
923 else
924 return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div");
925}
926
927Value *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) {
928 // Rem in C can't be a floating point type: C99 6.5.5p2.
Chris Lattner1f1ded92007-08-24 21:00:35 +0000929 if (Ops.Ty->isUnsignedIntegerType())
Chris Lattner7f02f722007-08-24 05:35:26 +0000930 return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem");
931 else
932 return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem");
933}
934
Mike Stump2add4732009-04-01 20:28:16 +0000935Value *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) {
936 unsigned IID;
937 unsigned OpID = 0;
Mike Stump5d8b2cf2009-04-02 01:03:55 +0000938
Mike Stump035cf892009-04-02 18:15:54 +0000939 switch (Ops.E->getOpcode()) {
940 case BinaryOperator::Add:
941 case BinaryOperator::AddAssign:
942 OpID = 1;
943 IID = llvm::Intrinsic::sadd_with_overflow;
944 break;
945 case BinaryOperator::Sub:
946 case BinaryOperator::SubAssign:
947 OpID = 2;
948 IID = llvm::Intrinsic::ssub_with_overflow;
949 break;
950 case BinaryOperator::Mul:
951 case BinaryOperator::MulAssign:
952 OpID = 3;
953 IID = llvm::Intrinsic::smul_with_overflow;
954 break;
955 default:
956 assert(false && "Unsupported operation for overflow detection");
Daniel Dunbarab4eff62009-04-08 16:23:09 +0000957 IID = 0;
Mike Stump2add4732009-04-01 20:28:16 +0000958 }
Mike Stump035cf892009-04-02 18:15:54 +0000959 OpID <<= 1;
960 OpID |= 1;
961
Mike Stump2add4732009-04-01 20:28:16 +0000962 const llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty);
963
964 llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, &opTy, 1);
965
966 Value *resultAndOverflow = Builder.CreateCall2(intrinsic, Ops.LHS, Ops.RHS);
967 Value *result = Builder.CreateExtractValue(resultAndOverflow, 0);
968 Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1);
969
970 // Branch in case of overflow.
971 llvm::BasicBlock *initialBB = Builder.GetInsertBlock();
972 llvm::BasicBlock *overflowBB =
973 CGF.createBasicBlock("overflow", CGF.CurFn);
974 llvm::BasicBlock *continueBB =
975 CGF.createBasicBlock("overflow.continue", CGF.CurFn);
976
977 Builder.CreateCondBr(overflow, overflowBB, continueBB);
978
979 // Handle overflow
980
981 Builder.SetInsertPoint(overflowBB);
982
983 // Handler is:
984 // long long *__overflow_handler)(long long a, long long b, char op,
985 // char width)
986 std::vector<const llvm::Type*> handerArgTypes;
987 handerArgTypes.push_back(llvm::Type::Int64Ty);
988 handerArgTypes.push_back(llvm::Type::Int64Ty);
989 handerArgTypes.push_back(llvm::Type::Int8Ty);
990 handerArgTypes.push_back(llvm::Type::Int8Ty);
Owen Andersona1cf15f2009-07-14 23:10:40 +0000991 llvm::FunctionType *handlerTy = VMContext.getFunctionType(llvm::Type::Int64Ty,
Mike Stump2add4732009-04-01 20:28:16 +0000992 handerArgTypes, false);
993 llvm::Value *handlerFunction =
994 CGF.CGM.getModule().getOrInsertGlobal("__overflow_handler",
Owen Andersona1cf15f2009-07-14 23:10:40 +0000995 VMContext.getPointerTypeUnqual(handlerTy));
Mike Stump2add4732009-04-01 20:28:16 +0000996 handlerFunction = Builder.CreateLoad(handlerFunction);
997
998 llvm::Value *handlerResult = Builder.CreateCall4(handlerFunction,
999 Builder.CreateSExt(Ops.LHS, llvm::Type::Int64Ty),
1000 Builder.CreateSExt(Ops.RHS, llvm::Type::Int64Ty),
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001001 llvm::ConstantInt::get(llvm::Type::Int8Ty, OpID),
1002 llvm::ConstantInt::get(llvm::Type::Int8Ty,
Mike Stump2add4732009-04-01 20:28:16 +00001003 cast<llvm::IntegerType>(opTy)->getBitWidth()));
1004
1005 handlerResult = Builder.CreateTrunc(handlerResult, opTy);
1006
1007 Builder.CreateBr(continueBB);
1008
1009 // Set up the continuation
1010 Builder.SetInsertPoint(continueBB);
1011 // Get the correct result
1012 llvm::PHINode *phi = Builder.CreatePHI(opTy);
1013 phi->reserveOperandSpace(2);
1014 phi->addIncoming(result, initialBB);
1015 phi->addIncoming(handlerResult, overflowBB);
1016
1017 return phi;
1018}
Chris Lattner7f02f722007-08-24 05:35:26 +00001019
1020Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) {
Steve Naroff58f9f2c2009-07-14 18:25:06 +00001021 if (!Ops.Ty->isAnyPointerType()) {
Chris Lattner87415d22009-06-17 06:36:24 +00001022 if (CGF.getContext().getLangOptions().OverflowChecking &&
1023 Ops.Ty->isSignedIntegerType())
Mike Stump2add4732009-04-01 20:28:16 +00001024 return EmitOverflowCheckedBinOp(Ops);
Chris Lattner87415d22009-06-17 06:36:24 +00001025
1026 if (Ops.LHS->getType()->isFPOrFPVector())
1027 return Builder.CreateFAdd(Ops.LHS, Ops.RHS, "add");
1028
Chris Lattner7f02f722007-08-24 05:35:26 +00001029 return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add");
Mike Stump2add4732009-04-01 20:28:16 +00001030 }
Eli Friedmandaa24a22009-03-28 02:45:41 +00001031
Steve Naroff14108da2009-07-10 23:34:53 +00001032 if (Ops.Ty->isPointerType() &&
Ted Kremenek35366a62009-07-17 17:50:17 +00001033 Ops.Ty->getAsPointerType()->isVariableArrayType()) {
Eli Friedmandaa24a22009-03-28 02:45:41 +00001034 // The amount of the addition needs to account for the VLA size
1035 CGF.ErrorUnsupported(Ops.E, "VLA pointer addition");
1036 }
Chris Lattner8f925282008-01-03 06:36:51 +00001037 Value *Ptr, *Idx;
1038 Expr *IdxExp;
Ted Kremenek35366a62009-07-17 17:50:17 +00001039 const PointerType *PT = Ops.E->getLHS()->getType()->getAsPointerType();
Steve Naroff14108da2009-07-10 23:34:53 +00001040 const ObjCObjectPointerType *OPT =
1041 Ops.E->getLHS()->getType()->getAsObjCObjectPointerType();
1042 if (PT || OPT) {
Chris Lattner8f925282008-01-03 06:36:51 +00001043 Ptr = Ops.LHS;
1044 Idx = Ops.RHS;
1045 IdxExp = Ops.E->getRHS();
Steve Naroff14108da2009-07-10 23:34:53 +00001046 } else { // int + pointer
Ted Kremenek35366a62009-07-17 17:50:17 +00001047 PT = Ops.E->getRHS()->getType()->getAsPointerType();
Steve Naroff14108da2009-07-10 23:34:53 +00001048 OPT = Ops.E->getRHS()->getType()->getAsObjCObjectPointerType();
1049 assert((PT || OPT) && "Invalid add expr");
Chris Lattner8f925282008-01-03 06:36:51 +00001050 Ptr = Ops.RHS;
1051 Idx = Ops.LHS;
1052 IdxExp = Ops.E->getLHS();
1053 }
1054
1055 unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth();
Sanjiv Gupta7cabee52009-04-24 02:40:57 +00001056 if (Width < CGF.LLVMPointerWidth) {
Chris Lattner8f925282008-01-03 06:36:51 +00001057 // Zero or sign extend the pointer value based on whether the index is
1058 // signed or not.
Owen Andersona1cf15f2009-07-14 23:10:40 +00001059 const llvm::Type *IdxType = VMContext.getIntegerType(CGF.LLVMPointerWidth);
Chris Lattner96196622008-07-26 22:37:01 +00001060 if (IdxExp->getType()->isSignedIntegerType())
Chris Lattner8f925282008-01-03 06:36:51 +00001061 Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext");
1062 else
1063 Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext");
1064 }
Steve Naroff14108da2009-07-10 23:34:53 +00001065 const QualType ElementType = PT ? PT->getPointeeType() : OPT->getPointeeType();
Daniel Dunbar2a866252009-04-25 05:08:32 +00001066 // Handle interface types, which are not represented with a concrete
1067 // type.
1068 if (const ObjCInterfaceType *OIT = dyn_cast<ObjCInterfaceType>(ElementType)) {
1069 llvm::Value *InterfaceSize =
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001070 llvm::ConstantInt::get(Idx->getType(),
Daniel Dunbar2a866252009-04-25 05:08:32 +00001071 CGF.getContext().getTypeSize(OIT) / 8);
1072 Idx = Builder.CreateMul(Idx, InterfaceSize);
Owen Andersona1cf15f2009-07-14 23:10:40 +00001073 const llvm::Type *i8Ty = VMContext.getPointerTypeUnqual(llvm::Type::Int8Ty);
Daniel Dunbar2a866252009-04-25 05:08:32 +00001074 Value *Casted = Builder.CreateBitCast(Ptr, i8Ty);
1075 Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr");
1076 return Builder.CreateBitCast(Res, Ptr->getType());
1077 }
1078
Daniel Dunbarb09fae72009-01-23 18:51:09 +00001079 // Explicitly handle GNU void* and function pointer arithmetic
1080 // extensions. The GNU void* casts amount to no-ops since our void*
1081 // type is i8*, but this is future proof.
Daniel Dunbarb09fae72009-01-23 18:51:09 +00001082 if (ElementType->isVoidType() || ElementType->isFunctionType()) {
Owen Andersona1cf15f2009-07-14 23:10:40 +00001083 const llvm::Type *i8Ty = VMContext.getPointerTypeUnqual(llvm::Type::Int8Ty);
Daniel Dunbarb09fae72009-01-23 18:51:09 +00001084 Value *Casted = Builder.CreateBitCast(Ptr, i8Ty);
Daniel Dunbar2a866252009-04-25 05:08:32 +00001085 Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr");
Daniel Dunbarb09fae72009-01-23 18:51:09 +00001086 return Builder.CreateBitCast(Res, Ptr->getType());
1087 }
Chris Lattner8f925282008-01-03 06:36:51 +00001088
1089 return Builder.CreateGEP(Ptr, Idx, "add.ptr");
Chris Lattner7f02f722007-08-24 05:35:26 +00001090}
1091
1092Value *ScalarExprEmitter::EmitSub(const BinOpInfo &Ops) {
Mike Stump2add4732009-04-01 20:28:16 +00001093 if (!isa<llvm::PointerType>(Ops.LHS->getType())) {
Mike Stump035cf892009-04-02 18:15:54 +00001094 if (CGF.getContext().getLangOptions().OverflowChecking
1095 && Ops.Ty->isSignedIntegerType())
Mike Stump2add4732009-04-01 20:28:16 +00001096 return EmitOverflowCheckedBinOp(Ops);
Chris Lattner87415d22009-06-17 06:36:24 +00001097
1098 if (Ops.LHS->getType()->isFPOrFPVector())
1099 return Builder.CreateFSub(Ops.LHS, Ops.RHS, "sub");
Chris Lattner7f02f722007-08-24 05:35:26 +00001100 return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub");
Mike Stump2add4732009-04-01 20:28:16 +00001101 }
Chris Lattner1f1ded92007-08-24 21:00:35 +00001102
Steve Naroff14108da2009-07-10 23:34:53 +00001103 if (Ops.E->getLHS()->getType()->isPointerType() &&
Ted Kremenek35366a62009-07-17 17:50:17 +00001104 Ops.E->getLHS()->getType()->getAsPointerType()->isVariableArrayType()) {
Eli Friedmandaa24a22009-03-28 02:45:41 +00001105 // The amount of the addition needs to account for the VLA size for
1106 // ptr-int
1107 // The amount of the division needs to account for the VLA size for
1108 // ptr-ptr.
1109 CGF.ErrorUnsupported(Ops.E, "VLA pointer subtraction");
1110 }
1111
Daniel Dunbarb09fae72009-01-23 18:51:09 +00001112 const QualType LHSType = Ops.E->getLHS()->getType();
Steve Naroff14108da2009-07-10 23:34:53 +00001113 const QualType LHSElementType = LHSType->getPointeeType();
Daniel Dunbar8c6f57c2008-08-06 02:00:38 +00001114 if (!isa<llvm::PointerType>(Ops.RHS->getType())) {
1115 // pointer - int
1116 Value *Idx = Ops.RHS;
1117 unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth();
Sanjiv Gupta7cabee52009-04-24 02:40:57 +00001118 if (Width < CGF.LLVMPointerWidth) {
Daniel Dunbar8c6f57c2008-08-06 02:00:38 +00001119 // Zero or sign extend the pointer value based on whether the index is
1120 // signed or not.
Owen Andersona1cf15f2009-07-14 23:10:40 +00001121 const llvm::Type *IdxType =
1122 VMContext.getIntegerType(CGF.LLVMPointerWidth);
Daniel Dunbar8c6f57c2008-08-06 02:00:38 +00001123 if (Ops.E->getRHS()->getType()->isSignedIntegerType())
1124 Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext");
1125 else
1126 Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext");
1127 }
1128 Idx = Builder.CreateNeg(Idx, "sub.ptr.neg");
Daniel Dunbarb09fae72009-01-23 18:51:09 +00001129
Daniel Dunbar2a866252009-04-25 05:08:32 +00001130 // Handle interface types, which are not represented with a concrete
1131 // type.
1132 if (const ObjCInterfaceType *OIT =
1133 dyn_cast<ObjCInterfaceType>(LHSElementType)) {
1134 llvm::Value *InterfaceSize =
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001135 llvm::ConstantInt::get(Idx->getType(),
Daniel Dunbar2a866252009-04-25 05:08:32 +00001136 CGF.getContext().getTypeSize(OIT) / 8);
1137 Idx = Builder.CreateMul(Idx, InterfaceSize);
Owen Andersona1cf15f2009-07-14 23:10:40 +00001138 const llvm::Type *i8Ty =
1139 VMContext.getPointerTypeUnqual(llvm::Type::Int8Ty);
Daniel Dunbar2a866252009-04-25 05:08:32 +00001140 Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty);
1141 Value *Res = Builder.CreateGEP(LHSCasted, Idx, "add.ptr");
1142 return Builder.CreateBitCast(Res, Ops.LHS->getType());
1143 }
1144
Daniel Dunbarb09fae72009-01-23 18:51:09 +00001145 // Explicitly handle GNU void* and function pointer arithmetic
1146 // extensions. The GNU void* casts amount to no-ops since our
1147 // void* type is i8*, but this is future proof.
1148 if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) {
Owen Andersona1cf15f2009-07-14 23:10:40 +00001149 const llvm::Type *i8Ty =
1150 VMContext.getPointerTypeUnqual(llvm::Type::Int8Ty);
Daniel Dunbarb09fae72009-01-23 18:51:09 +00001151 Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty);
1152 Value *Res = Builder.CreateGEP(LHSCasted, Idx, "sub.ptr");
1153 return Builder.CreateBitCast(Res, Ops.LHS->getType());
1154 }
1155
Daniel Dunbar8c6f57c2008-08-06 02:00:38 +00001156 return Builder.CreateGEP(Ops.LHS, Idx, "sub.ptr");
Daniel Dunbar820b0332008-08-05 00:47:03 +00001157 } else {
Daniel Dunbar8c6f57c2008-08-06 02:00:38 +00001158 // pointer - pointer
1159 Value *LHS = Ops.LHS;
1160 Value *RHS = Ops.RHS;
Chris Lattner1f1ded92007-08-24 21:00:35 +00001161
Daniel Dunbar8c6f57c2008-08-06 02:00:38 +00001162 uint64_t ElementSize;
Daniel Dunbar820b0332008-08-05 00:47:03 +00001163
Chris Lattnere5ed1512009-02-11 07:21:43 +00001164 // Handle GCC extension for pointer arithmetic on void* and function pointer
1165 // types.
1166 if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) {
Daniel Dunbar8c6f57c2008-08-06 02:00:38 +00001167 ElementSize = 1;
1168 } else {
1169 ElementSize = CGF.getContext().getTypeSize(LHSElementType) / 8;
1170 }
1171
1172 const llvm::Type *ResultType = ConvertType(Ops.Ty);
1173 LHS = Builder.CreatePtrToInt(LHS, ResultType, "sub.ptr.lhs.cast");
1174 RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast");
1175 Value *BytesBetween = Builder.CreateSub(LHS, RHS, "sub.ptr.sub");
1176
Chris Lattnere5ed1512009-02-11 07:21:43 +00001177 // Optimize out the shift for element size of 1.
1178 if (ElementSize == 1)
1179 return BytesBetween;
1180
Daniel Dunbar8c6f57c2008-08-06 02:00:38 +00001181 // HACK: LLVM doesn't have an divide instruction that 'knows' there is no
1182 // remainder. As such, we handle common power-of-two cases here to generate
1183 // better code. See PR2247.
1184 if (llvm::isPowerOf2_64(ElementSize)) {
1185 Value *ShAmt =
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001186 llvm::ConstantInt::get(ResultType, llvm::Log2_64(ElementSize));
Daniel Dunbar8c6f57c2008-08-06 02:00:38 +00001187 return Builder.CreateAShr(BytesBetween, ShAmt, "sub.ptr.shr");
1188 }
1189
1190 // Otherwise, do a full sdiv.
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001191 Value *BytesPerElt = llvm::ConstantInt::get(ResultType, ElementSize);
Daniel Dunbar8c6f57c2008-08-06 02:00:38 +00001192 return Builder.CreateSDiv(BytesBetween, BytesPerElt, "sub.ptr.div");
Chris Lattner7f02f722007-08-24 05:35:26 +00001193 }
Chris Lattner7f02f722007-08-24 05:35:26 +00001194}
1195
1196Value *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) {
1197 // LLVM requires the LHS and RHS to be the same type: promote or truncate the
1198 // RHS to the same size as the LHS.
1199 Value *RHS = Ops.RHS;
1200 if (Ops.LHS->getType() != RHS->getType())
1201 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
1202
1203 return Builder.CreateShl(Ops.LHS, RHS, "shl");
1204}
1205
1206Value *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) {
1207 // LLVM requires the LHS and RHS to be the same type: promote or truncate the
1208 // RHS to the same size as the LHS.
1209 Value *RHS = Ops.RHS;
1210 if (Ops.LHS->getType() != RHS->getType())
1211 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
1212
Chris Lattner1f1ded92007-08-24 21:00:35 +00001213 if (Ops.Ty->isUnsignedIntegerType())
Chris Lattner7f02f722007-08-24 05:35:26 +00001214 return Builder.CreateLShr(Ops.LHS, RHS, "shr");
1215 return Builder.CreateAShr(Ops.LHS, RHS, "shr");
1216}
1217
1218Value *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc,
1219 unsigned SICmpOpc, unsigned FCmpOpc) {
Mike Stump7f79f9b2009-05-29 15:46:01 +00001220 TestAndClearIgnoreResultAssign();
Chris Lattner4f1a7b32007-08-26 16:34:22 +00001221 Value *Result;
Chris Lattner7f02f722007-08-24 05:35:26 +00001222 QualType LHSTy = E->getLHS()->getType();
Chris Lattner9c10fcf2009-07-08 01:08:03 +00001223 if (!LHSTy->isAnyComplexType()) {
Chris Lattner7f02f722007-08-24 05:35:26 +00001224 Value *LHS = Visit(E->getLHS());
1225 Value *RHS = Visit(E->getRHS());
1226
Eli Friedman1360d4a2009-07-22 06:07:16 +00001227 if (LHS->getType()->isFPOrFPVector()) {
Nate Begeman7a66d7b2008-07-25 20:16:05 +00001228 Result = Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc,
Chris Lattner7f02f722007-08-24 05:35:26 +00001229 LHS, RHS, "cmp");
Eli Friedmanec2c1262008-05-29 15:09:15 +00001230 } else if (LHSTy->isSignedIntegerType()) {
1231 Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc,
Chris Lattner7f02f722007-08-24 05:35:26 +00001232 LHS, RHS, "cmp");
1233 } else {
Eli Friedmanec2c1262008-05-29 15:09:15 +00001234 // Unsigned integers and pointers.
1235 Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
Chris Lattner7f02f722007-08-24 05:35:26 +00001236 LHS, RHS, "cmp");
1237 }
Chris Lattner9c10fcf2009-07-08 01:08:03 +00001238
1239 // If this is a vector comparison, sign extend the result to the appropriate
1240 // vector integer type and return it (don't convert to bool).
1241 if (LHSTy->isVectorType())
1242 return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
Nate Begeman7a66d7b2008-07-25 20:16:05 +00001243
Chris Lattner7f02f722007-08-24 05:35:26 +00001244 } else {
1245 // Complex Comparison: can only be an equality comparison.
1246 CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS());
1247 CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS());
1248
Chris Lattner96196622008-07-26 22:37:01 +00001249 QualType CETy = LHSTy->getAsComplexType()->getElementType();
Chris Lattner7f02f722007-08-24 05:35:26 +00001250
Chris Lattner4f1a7b32007-08-26 16:34:22 +00001251 Value *ResultR, *ResultI;
Chris Lattner7f02f722007-08-24 05:35:26 +00001252 if (CETy->isRealFloatingType()) {
1253 ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc,
1254 LHS.first, RHS.first, "cmp.r");
1255 ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc,
1256 LHS.second, RHS.second, "cmp.i");
1257 } else {
1258 // Complex comparisons can only be equality comparisons. As such, signed
1259 // and unsigned opcodes are the same.
1260 ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
1261 LHS.first, RHS.first, "cmp.r");
1262 ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
1263 LHS.second, RHS.second, "cmp.i");
1264 }
1265
1266 if (E->getOpcode() == BinaryOperator::EQ) {
1267 Result = Builder.CreateAnd(ResultR, ResultI, "and.ri");
1268 } else {
1269 assert(E->getOpcode() == BinaryOperator::NE &&
1270 "Complex comparison other than == or != ?");
1271 Result = Builder.CreateOr(ResultR, ResultI, "or.ri");
1272 }
1273 }
Nuno Lopes32f62092009-01-11 23:22:37 +00001274
1275 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType());
Chris Lattner7f02f722007-08-24 05:35:26 +00001276}
1277
1278Value *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) {
Mike Stump7f79f9b2009-05-29 15:46:01 +00001279 bool Ignore = TestAndClearIgnoreResultAssign();
1280
1281 // __block variables need to have the rhs evaluated first, plus this should
1282 // improve codegen just a little.
Chris Lattner7f02f722007-08-24 05:35:26 +00001283 Value *RHS = Visit(E->getRHS());
Mike Stump99459b62009-05-21 21:05:15 +00001284 LValue LHS = EmitLValue(E->getLHS());
Chris Lattner7f02f722007-08-24 05:35:26 +00001285
Daniel Dunbared3849b2008-11-19 09:36:46 +00001286 // Store the value into the LHS. Bit-fields are handled specially
Daniel Dunbar371d16f2008-11-19 11:54:05 +00001287 // because the result is altered by the store, i.e., [C99 6.5.16p1]
1288 // 'An assignment expression has the value of the left operand after
Eli Friedmandaa24a22009-03-28 02:45:41 +00001289 // the assignment...'.
Mike Stump7f79f9b2009-05-29 15:46:01 +00001290 if (LHS.isBitfield()) {
1291 if (!LHS.isVolatileQualified()) {
1292 CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, E->getType(),
1293 &RHS);
1294 return RHS;
1295 } else
1296 CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, E->getType());
1297 } else
Daniel Dunbared3849b2008-11-19 09:36:46 +00001298 CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS, E->getType());
Mike Stump7f79f9b2009-05-29 15:46:01 +00001299 if (Ignore)
1300 return 0;
1301 return EmitLoadOfLValue(LHS, E->getType());
Chris Lattner7f02f722007-08-24 05:35:26 +00001302}
1303
1304Value *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) {
Chris Lattner20eb09d2008-11-12 08:26:50 +00001305 // If we have 0 && RHS, see if we can elide RHS, if so, just return 0.
1306 // If we have 1 && X, just emit X without inserting the control flow.
1307 if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) {
1308 if (Cond == 1) { // If we have 1 && X, just emit X.
Chris Lattner0946ccd2008-11-11 07:41:27 +00001309 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
1310 // ZExt result to int.
1311 return Builder.CreateZExt(RHSCond, CGF.LLVMIntTy, "land.ext");
1312 }
Chris Lattner20eb09d2008-11-12 08:26:50 +00001313
1314 // 0 && RHS: If it is safe, just elide the RHS, and return 0.
1315 if (!CGF.ContainsLabel(E->getRHS()))
Owen Andersona1cf15f2009-07-14 23:10:40 +00001316 return VMContext.getNullValue(CGF.LLVMIntTy);
Chris Lattner0946ccd2008-11-11 07:41:27 +00001317 }
1318
Daniel Dunbar9615ecb2008-11-13 01:38:36 +00001319 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end");
1320 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs");
Chris Lattner20eb09d2008-11-12 08:26:50 +00001321
Chris Lattnerf7b5ea92008-11-12 08:38:24 +00001322 // Branch on the LHS first. If it is false, go to the failure (cont) block.
1323 CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock);
1324
1325 // Any edges into the ContBlock are now from an (indeterminate number of)
1326 // edges from this first condition. All of these values will be false. Start
1327 // setting up the PHI node in the Cont Block for this.
1328 llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::Int1Ty, "", ContBlock);
1329 PN->reserveOperandSpace(2); // Normal case, two inputs.
1330 for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock);
1331 PI != PE; ++PI)
Owen Anderson4cd16082009-07-21 18:06:41 +00001332 PN->addIncoming(VMContext.getFalse(), *PI);
Chris Lattner7f02f722007-08-24 05:35:26 +00001333
Anders Carlsson33da07d2009-06-04 02:53:13 +00001334 CGF.PushConditionalTempDestruction();
Chris Lattner7f02f722007-08-24 05:35:26 +00001335 CGF.EmitBlock(RHSBlock);
1336 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
Anders Carlsson33da07d2009-06-04 02:53:13 +00001337 CGF.PopConditionalTempDestruction();
Chris Lattner7f02f722007-08-24 05:35:26 +00001338
1339 // Reaquire the RHS block, as there may be subblocks inserted.
1340 RHSBlock = Builder.GetInsertBlock();
Chris Lattnerf7b5ea92008-11-12 08:38:24 +00001341
1342 // Emit an unconditional branch from this block to ContBlock. Insert an entry
1343 // into the phi node for the edge with the value of RHSCond.
Chris Lattner7f02f722007-08-24 05:35:26 +00001344 CGF.EmitBlock(ContBlock);
Chris Lattner7f02f722007-08-24 05:35:26 +00001345 PN->addIncoming(RHSCond, RHSBlock);
1346
1347 // ZExt result to int.
1348 return Builder.CreateZExt(PN, CGF.LLVMIntTy, "land.ext");
1349}
1350
1351Value *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) {
Chris Lattner20eb09d2008-11-12 08:26:50 +00001352 // If we have 1 || RHS, see if we can elide RHS, if so, just return 1.
1353 // If we have 0 || X, just emit X without inserting the control flow.
1354 if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) {
1355 if (Cond == -1) { // If we have 0 || X, just emit X.
Chris Lattner0946ccd2008-11-11 07:41:27 +00001356 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
1357 // ZExt result to int.
1358 return Builder.CreateZExt(RHSCond, CGF.LLVMIntTy, "lor.ext");
1359 }
Chris Lattner20eb09d2008-11-12 08:26:50 +00001360
Eli Friedman8de8d1d2008-12-02 16:02:46 +00001361 // 1 || RHS: If it is safe, just elide the RHS, and return 1.
Chris Lattner20eb09d2008-11-12 08:26:50 +00001362 if (!CGF.ContainsLabel(E->getRHS()))
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001363 return llvm::ConstantInt::get(CGF.LLVMIntTy, 1);
Chris Lattner0946ccd2008-11-11 07:41:27 +00001364 }
1365
Daniel Dunbar9615ecb2008-11-13 01:38:36 +00001366 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end");
1367 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs");
Chris Lattner7f02f722007-08-24 05:35:26 +00001368
Chris Lattnerf7b5ea92008-11-12 08:38:24 +00001369 // Branch on the LHS first. If it is true, go to the success (cont) block.
1370 CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock);
1371
1372 // Any edges into the ContBlock are now from an (indeterminate number of)
1373 // edges from this first condition. All of these values will be true. Start
1374 // setting up the PHI node in the Cont Block for this.
1375 llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::Int1Ty, "", ContBlock);
1376 PN->reserveOperandSpace(2); // Normal case, two inputs.
1377 for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock);
1378 PI != PE; ++PI)
Owen Anderson4cd16082009-07-21 18:06:41 +00001379 PN->addIncoming(VMContext.getTrue(), *PI);
Chris Lattnerf7b5ea92008-11-12 08:38:24 +00001380
Anders Carlsson33da07d2009-06-04 02:53:13 +00001381 CGF.PushConditionalTempDestruction();
1382
Chris Lattnerf7b5ea92008-11-12 08:38:24 +00001383 // Emit the RHS condition as a bool value.
Chris Lattner7f02f722007-08-24 05:35:26 +00001384 CGF.EmitBlock(RHSBlock);
1385 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
1386
Anders Carlsson33da07d2009-06-04 02:53:13 +00001387 CGF.PopConditionalTempDestruction();
1388
Chris Lattner7f02f722007-08-24 05:35:26 +00001389 // Reaquire the RHS block, as there may be subblocks inserted.
1390 RHSBlock = Builder.GetInsertBlock();
Chris Lattner7f02f722007-08-24 05:35:26 +00001391
Chris Lattnerf7b5ea92008-11-12 08:38:24 +00001392 // Emit an unconditional branch from this block to ContBlock. Insert an entry
1393 // into the phi node for the edge with the value of RHSCond.
1394 CGF.EmitBlock(ContBlock);
Chris Lattner7f02f722007-08-24 05:35:26 +00001395 PN->addIncoming(RHSCond, RHSBlock);
1396
1397 // ZExt result to int.
1398 return Builder.CreateZExt(PN, CGF.LLVMIntTy, "lor.ext");
1399}
1400
1401Value *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) {
1402 CGF.EmitStmt(E->getLHS());
Daniel Dunbara448fb22008-11-11 23:11:34 +00001403 CGF.EnsureInsertPoint();
Chris Lattner7f02f722007-08-24 05:35:26 +00001404 return Visit(E->getRHS());
1405}
1406
1407//===----------------------------------------------------------------------===//
1408// Other Operators
1409//===----------------------------------------------------------------------===//
1410
Chris Lattner9802a512008-11-12 08:55:54 +00001411/// isCheapEnoughToEvaluateUnconditionally - Return true if the specified
1412/// expression is cheap enough and side-effect-free enough to evaluate
1413/// unconditionally instead of conditionally. This is used to convert control
1414/// flow into selects in some cases.
1415static bool isCheapEnoughToEvaluateUnconditionally(const Expr *E) {
1416 if (const ParenExpr *PE = dyn_cast<ParenExpr>(E))
1417 return isCheapEnoughToEvaluateUnconditionally(PE->getSubExpr());
1418
1419 // TODO: Allow anything we can constant fold to an integer or fp constant.
1420 if (isa<IntegerLiteral>(E) || isa<CharacterLiteral>(E) ||
1421 isa<FloatingLiteral>(E))
1422 return true;
1423
1424 // Non-volatile automatic variables too, to get "cond ? X : Y" where
1425 // X and Y are local variables.
1426 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
1427 if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl()))
1428 if (VD->hasLocalStorage() && !VD->getType().isVolatileQualified())
1429 return true;
1430
1431 return false;
1432}
1433
1434
Chris Lattner7f02f722007-08-24 05:35:26 +00001435Value *ScalarExprEmitter::
1436VisitConditionalOperator(const ConditionalOperator *E) {
Mike Stump7f79f9b2009-05-29 15:46:01 +00001437 TestAndClearIgnoreResultAssign();
Chris Lattner31a09842008-11-12 08:04:58 +00001438 // If the condition constant folds and can be elided, try to avoid emitting
1439 // the condition and the dead arm.
1440 if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getCond())){
Chris Lattnerc657e922008-11-11 18:56:45 +00001441 Expr *Live = E->getLHS(), *Dead = E->getRHS();
Chris Lattner31a09842008-11-12 08:04:58 +00001442 if (Cond == -1)
Chris Lattnerc657e922008-11-11 18:56:45 +00001443 std::swap(Live, Dead);
Chris Lattner31a09842008-11-12 08:04:58 +00001444
1445 // If the dead side doesn't have labels we need, and if the Live side isn't
1446 // the gnu missing ?: extension (which we could handle, but don't bother
1447 // to), just emit the Live part.
1448 if ((!Dead || !CGF.ContainsLabel(Dead)) && // No labels in dead part
1449 Live) // Live part isn't missing.
1450 return Visit(Live);
Chris Lattnerc657e922008-11-11 18:56:45 +00001451 }
1452
Chris Lattner9802a512008-11-12 08:55:54 +00001453
1454 // If this is a really simple expression (like x ? 4 : 5), emit this as a
1455 // select instead of as control flow. We can only do this if it is cheap and
Chris Lattner531a5502008-11-16 06:16:27 +00001456 // safe to evaluate the LHS and RHS unconditionally.
Chris Lattner9802a512008-11-12 08:55:54 +00001457 if (E->getLHS() && isCheapEnoughToEvaluateUnconditionally(E->getLHS()) &&
1458 isCheapEnoughToEvaluateUnconditionally(E->getRHS())) {
1459 llvm::Value *CondV = CGF.EvaluateExprAsBool(E->getCond());
1460 llvm::Value *LHS = Visit(E->getLHS());
1461 llvm::Value *RHS = Visit(E->getRHS());
1462 return Builder.CreateSelect(CondV, LHS, RHS, "cond");
1463 }
1464
1465
Daniel Dunbarbe65abc2008-11-12 10:13:37 +00001466 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
1467 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
Daniel Dunbar9615ecb2008-11-13 01:38:36 +00001468 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
Chris Lattner035cf422008-11-12 08:08:13 +00001469 Value *CondVal = 0;
Chris Lattner31a09842008-11-12 08:04:58 +00001470
Chris Lattner12d152f2009-02-13 23:35:32 +00001471 // If we don't have the GNU missing condition extension, emit a branch on
1472 // bool the normal way.
1473 if (E->getLHS()) {
1474 // Otherwise, just use EmitBranchOnBoolExpr to get small and simple code for
1475 // the branch on bool.
1476 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock);
1477 } else {
1478 // Otherwise, for the ?: extension, evaluate the conditional and then
1479 // convert it to bool the hard way. We do this explicitly because we need
1480 // the unconverted value for the missing middle value of the ?:.
Chris Lattner035cf422008-11-12 08:08:13 +00001481 CondVal = CGF.EmitScalarExpr(E->getCond());
Chris Lattner12d152f2009-02-13 23:35:32 +00001482
1483 // In some cases, EmitScalarConversion will delete the "CondVal" expression
1484 // if there are no extra uses (an optimization). Inhibit this by making an
1485 // extra dead use, because we're going to add a use of CondVal later. We
1486 // don't use the builder for this, because we don't want it to get optimized
1487 // away. This leaves dead code, but the ?: extension isn't common.
1488 new llvm::BitCastInst(CondVal, CondVal->getType(), "dummy?:holder",
1489 Builder.GetInsertBlock());
1490
Chris Lattner035cf422008-11-12 08:08:13 +00001491 Value *CondBoolVal =
1492 CGF.EmitScalarConversion(CondVal, E->getCond()->getType(),
1493 CGF.getContext().BoolTy);
1494 Builder.CreateCondBr(CondBoolVal, LHSBlock, RHSBlock);
Chris Lattner035cf422008-11-12 08:08:13 +00001495 }
Anders Carlssonfb6fa302009-06-04 03:00:32 +00001496
1497 CGF.PushConditionalTempDestruction();
Chris Lattner7f02f722007-08-24 05:35:26 +00001498 CGF.EmitBlock(LHSBlock);
1499
1500 // Handle the GNU extension for missing LHS.
Chris Lattnera21ddb32007-11-26 01:40:58 +00001501 Value *LHS;
1502 if (E->getLHS())
Eli Friedman856226c2008-05-16 20:38:39 +00001503 LHS = Visit(E->getLHS());
Chris Lattnera21ddb32007-11-26 01:40:58 +00001504 else // Perform promotions, to handle cases like "short ?: int"
1505 LHS = EmitScalarConversion(CondVal, E->getCond()->getType(), E->getType());
1506
Anders Carlssonfb6fa302009-06-04 03:00:32 +00001507 CGF.PopConditionalTempDestruction();
Chris Lattner7f02f722007-08-24 05:35:26 +00001508 LHSBlock = Builder.GetInsertBlock();
Daniel Dunbard57a8712008-11-11 09:41:28 +00001509 CGF.EmitBranch(ContBlock);
Chris Lattner7f02f722007-08-24 05:35:26 +00001510
Anders Carlssonfb6fa302009-06-04 03:00:32 +00001511 CGF.PushConditionalTempDestruction();
Chris Lattner7f02f722007-08-24 05:35:26 +00001512 CGF.EmitBlock(RHSBlock);
1513
Eli Friedman856226c2008-05-16 20:38:39 +00001514 Value *RHS = Visit(E->getRHS());
Anders Carlssonfb6fa302009-06-04 03:00:32 +00001515 CGF.PopConditionalTempDestruction();
Chris Lattner7f02f722007-08-24 05:35:26 +00001516 RHSBlock = Builder.GetInsertBlock();
Daniel Dunbard57a8712008-11-11 09:41:28 +00001517 CGF.EmitBranch(ContBlock);
Chris Lattner7f02f722007-08-24 05:35:26 +00001518
1519 CGF.EmitBlock(ContBlock);
1520
Nuno Lopes108f55d2008-06-04 19:15:45 +00001521 if (!LHS || !RHS) {
Chris Lattner2202bce2007-11-30 17:56:23 +00001522 assert(E->getType()->isVoidType() && "Non-void value should have a value");
1523 return 0;
1524 }
1525
Chris Lattner7f02f722007-08-24 05:35:26 +00001526 // Create a PHI node for the real part.
1527 llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), "cond");
1528 PN->reserveOperandSpace(2);
1529 PN->addIncoming(LHS, LHSBlock);
1530 PN->addIncoming(RHS, RHSBlock);
1531 return PN;
1532}
1533
1534Value *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) {
Eli Friedman79769322009-03-04 05:52:32 +00001535 return Visit(E->getChosenSubExpr(CGF.getContext()));
Chris Lattner7f02f722007-08-24 05:35:26 +00001536}
1537
Chris Lattner2202bce2007-11-30 17:56:23 +00001538Value *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
Eli Friedman4fd0aa52009-01-20 17:46:04 +00001539 llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr());
Anders Carlssonddf7cac2008-11-04 05:30:00 +00001540 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType());
1541
1542 // If EmitVAArg fails, we fall back to the LLVM instruction.
1543 if (!ArgPtr)
1544 return Builder.CreateVAArg(ArgValue, ConvertType(VE->getType()));
1545
Mike Stump7f79f9b2009-05-29 15:46:01 +00001546 // FIXME Volatility.
Anders Carlssonddf7cac2008-11-04 05:30:00 +00001547 return Builder.CreateLoad(ArgPtr);
Anders Carlsson7c50aca2007-10-15 20:28:48 +00001548}
1549
Mike Stumpdf6b68c2009-02-12 18:29:15 +00001550Value *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *BE) {
Mike Stump08920992009-03-07 02:35:30 +00001551 return CGF.BuildBlockLiteralTmp(BE);
Mike Stumpdf6b68c2009-02-12 18:29:15 +00001552}
1553
Chris Lattner7f02f722007-08-24 05:35:26 +00001554//===----------------------------------------------------------------------===//
1555// Entry Point into this File
1556//===----------------------------------------------------------------------===//
1557
Mike Stump7f79f9b2009-05-29 15:46:01 +00001558/// EmitScalarExpr - Emit the computation of the specified expression of
1559/// scalar type, ignoring the result.
1560Value *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) {
Chris Lattner7f02f722007-08-24 05:35:26 +00001561 assert(E && !hasAggregateLLVMType(E->getType()) &&
1562 "Invalid scalar expression to emit");
1563
Mike Stump7f79f9b2009-05-29 15:46:01 +00001564 return ScalarExprEmitter(*this, IgnoreResultAssign)
1565 .Visit(const_cast<Expr*>(E));
Chris Lattner7f02f722007-08-24 05:35:26 +00001566}
Chris Lattner3707b252007-08-26 06:48:56 +00001567
1568/// EmitScalarConversion - Emit a conversion from the specified type to the
1569/// specified destination type, both of which are LLVM scalar types.
Chris Lattner4f1a7b32007-08-26 16:34:22 +00001570Value *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy,
1571 QualType DstTy) {
Chris Lattner3707b252007-08-26 06:48:56 +00001572 assert(!hasAggregateLLVMType(SrcTy) && !hasAggregateLLVMType(DstTy) &&
1573 "Invalid scalar expression to emit");
1574 return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy);
1575}
Chris Lattner4f1a7b32007-08-26 16:34:22 +00001576
1577/// EmitComplexToScalarConversion - Emit a conversion from the specified
1578/// complex type to the specified destination type, where the destination
1579/// type is an LLVM scalar type.
1580Value *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src,
1581 QualType SrcTy,
1582 QualType DstTy) {
Chris Lattner9b2dc282008-04-04 16:54:41 +00001583 assert(SrcTy->isAnyComplexType() && !hasAggregateLLVMType(DstTy) &&
Chris Lattner4f1a7b32007-08-26 16:34:22 +00001584 "Invalid complex -> scalar conversion");
1585 return ScalarExprEmitter(*this).EmitComplexToScalarConversion(Src, SrcTy,
1586 DstTy);
1587}
Anders Carlssoncc23aca2007-12-10 19:35:18 +00001588
1589Value *CodeGenFunction::EmitShuffleVector(Value* V1, Value *V2, ...) {
1590 assert(V1->getType() == V2->getType() &&
1591 "Vector operands must be of the same type");
Anders Carlssoncc23aca2007-12-10 19:35:18 +00001592 unsigned NumElements =
1593 cast<llvm::VectorType>(V1->getType())->getNumElements();
1594
1595 va_list va;
1596 va_start(va, V2);
1597
1598 llvm::SmallVector<llvm::Constant*, 16> Args;
Anders Carlssoncc23aca2007-12-10 19:35:18 +00001599 for (unsigned i = 0; i < NumElements; i++) {
1600 int n = va_arg(va, int);
Anders Carlssoncc23aca2007-12-10 19:35:18 +00001601 assert(n >= 0 && n < (int)NumElements * 2 &&
1602 "Vector shuffle index out of bounds!");
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001603 Args.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, n));
Anders Carlssoncc23aca2007-12-10 19:35:18 +00001604 }
1605
1606 const char *Name = va_arg(va, const char *);
1607 va_end(va);
1608
Owen Anderson4a289322009-07-28 21:22:35 +00001609 llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements);
Anders Carlssoncc23aca2007-12-10 19:35:18 +00001610
1611 return Builder.CreateShuffleVector(V1, V2, Mask, Name);
1612}
1613
Anders Carlsson6086bbd2007-12-15 21:23:30 +00001614llvm::Value *CodeGenFunction::EmitVector(llvm::Value * const *Vals,
Chris Lattner345f7202008-07-26 20:15:14 +00001615 unsigned NumVals, bool isSplat) {
Anders Carlsson6086bbd2007-12-15 21:23:30 +00001616 llvm::Value *Vec
Owen Andersona1cf15f2009-07-14 23:10:40 +00001617 = VMContext.getUndef(VMContext.getVectorType(Vals[0]->getType(), NumVals));
Anders Carlsson6086bbd2007-12-15 21:23:30 +00001618
Chris Lattner345f7202008-07-26 20:15:14 +00001619 for (unsigned i = 0, e = NumVals; i != e; ++i) {
Nate Begeman4119d1a2007-12-30 02:59:45 +00001620 llvm::Value *Val = isSplat ? Vals[0] : Vals[i];
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001621 llvm::Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, i);
Nate Begeman4119d1a2007-12-30 02:59:45 +00001622 Vec = Builder.CreateInsertElement(Vec, Val, Idx, "tmp");
Anders Carlsson6086bbd2007-12-15 21:23:30 +00001623 }
1624
1625 return Vec;
1626}