blob: 777be4da86dd3ab37cc36083b5d657188babfcad [file] [log] [blame]
Anders Carlsson022012e2007-08-20 18:05:56 +00001//===---- CGBuiltin.cpp - Emit LLVM Code for builtins ---------------------===//
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.
Anders Carlsson022012e2007-08-20 18:05:56 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This contains code to emit Builtin calls as LLVM code.
11//
12//===----------------------------------------------------------------------===//
13
John McCalld0b76ca2010-03-02 03:50:12 +000014#include "TargetInfo.h"
Anders Carlsson022012e2007-08-20 18:05:56 +000015#include "CodeGenFunction.h"
16#include "CodeGenModule.h"
Anders Carlssonca6fcfa2007-12-09 21:20:04 +000017#include "clang/Basic/TargetInfo.h"
Chris Lattner1f329992008-10-06 06:09:18 +000018#include "clang/AST/APValue.h"
Chris Lattnerbef20ac2007-08-31 04:31:45 +000019#include "clang/AST/ASTContext.h"
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000020#include "clang/AST/Decl.h"
Chris Lattner6b15cdc2009-06-14 01:05:48 +000021#include "clang/Basic/TargetBuiltins.h"
Anders Carlsson793680e2007-10-12 23:56:29 +000022#include "llvm/Intrinsics.h"
John McCalld0b76ca2010-03-02 03:50:12 +000023#include "llvm/Target/TargetData.h"
Anders Carlsson022012e2007-08-20 18:05:56 +000024using namespace clang;
25using namespace CodeGen;
Anders Carlssonca6fcfa2007-12-09 21:20:04 +000026using namespace llvm;
27
Daniel Dunbarcb61a7b2010-03-20 07:04:11 +000028static void EmitMemoryBarrier(CodeGenFunction &CGF,
29 bool LoadLoad, bool LoadStore,
30 bool StoreLoad, bool StoreStore,
31 bool Device) {
32 Value *True = llvm::ConstantInt::getTrue(CGF.getLLVMContext());
33 Value *False = llvm::ConstantInt::getFalse(CGF.getLLVMContext());
34 Value *C[5] = { LoadLoad ? True : False,
35 LoadStore ? True : False,
36 StoreLoad ? True : False,
37 StoreStore ? True : False,
38 Device ? True : False };
39 CGF.Builder.CreateCall(CGF.CGM.getIntrinsic(Intrinsic::memory_barrier),
40 C, C + 5);
41}
42
43// The atomic builtins are also full memory barriers. This is a utility for
44// wrapping a call to the builtins with memory barriers.
45static Value *EmitCallWithBarrier(CodeGenFunction &CGF, Value *Fn,
46 Value **ArgBegin, Value **ArgEnd) {
47 // FIXME: We need a target hook for whether this applies to device memory or
48 // not.
49 bool Device = true;
50
51 // Create barriers both before and after the call.
52 EmitMemoryBarrier(CGF, true, true, true, true, Device);
53 Value *Result = CGF.Builder.CreateCall(Fn, ArgBegin, ArgEnd);
54 EmitMemoryBarrier(CGF, true, true, true, true, Device);
55 return Result;
56}
57
Daniel Dunbar0002d232009-04-07 00:55:51 +000058/// Utility to insert an atomic instruction based on Instrinsic::ID
59/// and the expression node.
Daniel Dunbarcb61a7b2010-03-20 07:04:11 +000060static RValue EmitBinaryAtomic(CodeGenFunction &CGF,
Mon P Wang1ffe2812008-05-09 22:40:52 +000061 Intrinsic::ID Id, const CallExpr *E) {
Daniel Dunbarcb61a7b2010-03-20 07:04:11 +000062 Value *Args[2] = { CGF.EmitScalarExpr(E->getArg(0)),
63 CGF.EmitScalarExpr(E->getArg(1)) };
Mon P Wangc5004512008-07-31 03:28:23 +000064 const llvm::Type *ResType[2];
Daniel Dunbar0002d232009-04-07 00:55:51 +000065 ResType[0] = CGF.ConvertType(E->getType());
66 ResType[1] = CGF.ConvertType(E->getArg(0)->getType());
67 Value *AtomF = CGF.CGM.getIntrinsic(Id, ResType, 2);
Daniel Dunbarcb61a7b2010-03-20 07:04:11 +000068 return RValue::get(EmitCallWithBarrier(CGF, AtomF, Args, Args + 2));
Daniel Dunbar0002d232009-04-07 00:55:51 +000069}
70
71/// Utility to insert an atomic instruction based Instrinsic::ID and
72// the expression node, where the return value is the result of the
73// operation.
Chris Lattner420b1182010-05-06 05:35:16 +000074static RValue EmitBinaryAtomicPost(CodeGenFunction &CGF,
Daniel Dunbar0002d232009-04-07 00:55:51 +000075 Intrinsic::ID Id, const CallExpr *E,
76 Instruction::BinaryOps Op) {
77 const llvm::Type *ResType[2];
78 ResType[0] = CGF.ConvertType(E->getType());
79 ResType[1] = CGF.ConvertType(E->getArg(0)->getType());
80 Value *AtomF = CGF.CGM.getIntrinsic(Id, ResType, 2);
Daniel Dunbarcb61a7b2010-03-20 07:04:11 +000081 Value *Args[2] = { CGF.EmitScalarExpr(E->getArg(0)),
82 CGF.EmitScalarExpr(E->getArg(1)) };
83 Value *Result = EmitCallWithBarrier(CGF, AtomF, Args, Args + 2);
Daniel Dunbarcb61a7b2010-03-20 07:04:11 +000084 return RValue::get(CGF.Builder.CreateBinOp(Op, Result, Args[1]));
Mon P Wang1ffe2812008-05-09 22:40:52 +000085}
86
John McCallfb17a562010-03-03 10:30:05 +000087static llvm::ConstantInt *getInt32(llvm::LLVMContext &Context, int32_t Value) {
88 return llvm::ConstantInt::get(llvm::Type::getInt32Ty(Context), Value);
89}
90
Chris Lattner420b1182010-05-06 05:35:16 +000091
92/// EmitFAbs - Emit a call to fabs/fabsf/fabsl, depending on the type of ValTy,
93/// which must be a scalar floating point type.
94static Value *EmitFAbs(CodeGenFunction &CGF, Value *V, QualType ValTy) {
95 const BuiltinType *ValTyP = ValTy->getAs<BuiltinType>();
96 assert(ValTyP && "isn't scalar fp type!");
97
98 StringRef FnName;
99 switch (ValTyP->getKind()) {
100 default: assert(0 && "Isn't a scalar fp type!");
101 case BuiltinType::Float: FnName = "fabsf"; break;
102 case BuiltinType::Double: FnName = "fabs"; break;
103 case BuiltinType::LongDouble: FnName = "fabsl"; break;
104 }
105
106 // The prototype is something that takes and returns whatever V's type is.
107 std::vector<const llvm::Type*> Args;
108 Args.push_back(V->getType());
109 llvm::FunctionType *FT = llvm::FunctionType::get(V->getType(), Args, false);
110 llvm::Value *Fn = CGF.CGM.CreateRuntimeFunction(FT, FnName);
111
112 return CGF.Builder.CreateCall(Fn, V, "abs");
113}
114
Mike Stump1eb44332009-09-09 15:08:12 +0000115RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
Daniel Dunbaref2abfe2009-02-16 22:43:43 +0000116 unsigned BuiltinID, const CallExpr *E) {
Chris Lattner564ea2a2008-10-06 06:56:41 +0000117 // See if we can constant fold this builtin. If so, don't emit it at all.
Anders Carlssonf35d35a2008-12-01 02:31:41 +0000118 Expr::EvalResult Result;
Chris Lattner6ee7aa12008-11-16 21:24:15 +0000119 if (E->Evaluate(Result, CGM.getContext())) {
Anders Carlssonf35d35a2008-12-01 02:31:41 +0000120 if (Result.Val.isInt())
Mike Stump1eb44332009-09-09 15:08:12 +0000121 return RValue::get(llvm::ConstantInt::get(VMContext,
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000122 Result.Val.getInt()));
Eli Friedman3941b182009-01-25 01:54:01 +0000123 else if (Result.Val.isFloat())
Owen Andersonbc0a2222009-07-27 21:00:51 +0000124 return RValue::get(ConstantFP::get(VMContext, Result.Val.getFloat()));
Chris Lattner1f329992008-10-06 06:09:18 +0000125 }
Mike Stump1eb44332009-09-09 15:08:12 +0000126
Chris Lattner564ea2a2008-10-06 06:56:41 +0000127 switch (BuiltinID) {
128 default: break; // Handle intrinsics and libm functions below.
Chris Lattner506ff882008-10-06 07:26:43 +0000129 case Builtin::BI__builtin___CFStringMakeConstantString:
David Chisnall0d13f6f2010-01-23 02:40:42 +0000130 case Builtin::BI__builtin___NSStringMakeConstantString:
Anders Carlssone9352cc2009-04-08 04:48:15 +0000131 return RValue::get(CGM.EmitConstantExpr(E, E->getType(), 0));
Chris Lattner6a705f02008-07-09 17:28:44 +0000132 case Builtin::BI__builtin_stdarg_start:
Anders Carlsson793680e2007-10-12 23:56:29 +0000133 case Builtin::BI__builtin_va_start:
134 case Builtin::BI__builtin_va_end: {
Daniel Dunbar07855702009-02-11 22:25:55 +0000135 Value *ArgValue = EmitVAListRef(E->getArg(0));
Benjamin Kramer3c0ef8c2009-10-13 10:07:13 +0000136 const llvm::Type *DestType = llvm::Type::getInt8PtrTy(VMContext);
Anders Carlsson793680e2007-10-12 23:56:29 +0000137 if (ArgValue->getType() != DestType)
Mike Stump1eb44332009-09-09 15:08:12 +0000138 ArgValue = Builder.CreateBitCast(ArgValue, DestType,
Daniel Dunbarb27ffbe2009-07-26 09:28:40 +0000139 ArgValue->getName().data());
Anders Carlsson793680e2007-10-12 23:56:29 +0000140
Mike Stump1eb44332009-09-09 15:08:12 +0000141 Intrinsic::ID inst = (BuiltinID == Builtin::BI__builtin_va_end) ?
Chris Lattner6a705f02008-07-09 17:28:44 +0000142 Intrinsic::vaend : Intrinsic::vastart;
Chris Lattner7acda7c2007-12-18 00:25:38 +0000143 return RValue::get(Builder.CreateCall(CGM.getIntrinsic(inst), ArgValue));
Anders Carlsson793680e2007-10-12 23:56:29 +0000144 }
Anders Carlssona28ef8b2008-02-09 20:26:43 +0000145 case Builtin::BI__builtin_va_copy: {
Eli Friedman4fd0aa52009-01-20 17:46:04 +0000146 Value *DstPtr = EmitVAListRef(E->getArg(0));
147 Value *SrcPtr = EmitVAListRef(E->getArg(1));
Anders Carlssona28ef8b2008-02-09 20:26:43 +0000148
Benjamin Kramer3c0ef8c2009-10-13 10:07:13 +0000149 const llvm::Type *Type = llvm::Type::getInt8PtrTy(VMContext);
Anders Carlssona28ef8b2008-02-09 20:26:43 +0000150
151 DstPtr = Builder.CreateBitCast(DstPtr, Type);
152 SrcPtr = Builder.CreateBitCast(SrcPtr, Type);
Mike Stump1eb44332009-09-09 15:08:12 +0000153 return RValue::get(Builder.CreateCall2(CGM.getIntrinsic(Intrinsic::vacopy),
Chris Lattner3eae03e2008-05-06 00:56:42 +0000154 DstPtr, SrcPtr));
Anders Carlssona28ef8b2008-02-09 20:26:43 +0000155 }
Anders Carlssonc2251dc2007-11-20 19:05:17 +0000156 case Builtin::BI__builtin_abs: {
Mike Stump1eb44332009-09-09 15:08:12 +0000157 Value *ArgValue = EmitScalarExpr(E->getArg(0));
158
Chris Lattner9a847f52008-07-23 06:53:34 +0000159 Value *NegOp = Builder.CreateNeg(ArgValue, "neg");
Mike Stump1eb44332009-09-09 15:08:12 +0000160 Value *CmpResult =
161 Builder.CreateICmpSGE(ArgValue,
Owen Andersonc9c88b42009-07-31 20:28:54 +0000162 llvm::Constant::getNullValue(ArgValue->getType()),
Chris Lattner9a847f52008-07-23 06:53:34 +0000163 "abscond");
Mike Stump1eb44332009-09-09 15:08:12 +0000164 Value *Result =
Anders Carlssonc2251dc2007-11-20 19:05:17 +0000165 Builder.CreateSelect(CmpResult, ArgValue, NegOp, "abs");
Mike Stump1eb44332009-09-09 15:08:12 +0000166
Anders Carlssonc2251dc2007-11-20 19:05:17 +0000167 return RValue::get(Result);
168 }
Anders Carlsson3a31d602008-02-06 07:19:27 +0000169 case Builtin::BI__builtin_ctz:
170 case Builtin::BI__builtin_ctzl:
171 case Builtin::BI__builtin_ctzll: {
172 Value *ArgValue = EmitScalarExpr(E->getArg(0));
Mike Stump1eb44332009-09-09 15:08:12 +0000173
Anders Carlsson3a31d602008-02-06 07:19:27 +0000174 const llvm::Type *ArgType = ArgValue->getType();
175 Value *F = CGM.getIntrinsic(Intrinsic::cttz, &ArgType, 1);
176
Mike Stump1eb44332009-09-09 15:08:12 +0000177 const llvm::Type *ResultType = ConvertType(E->getType());
Anders Carlsson3a31d602008-02-06 07:19:27 +0000178 Value *Result = Builder.CreateCall(F, ArgValue, "tmp");
179 if (Result->getType() != ResultType)
Duncan Sandseac73e52009-11-16 13:11:21 +0000180 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
181 "cast");
Anders Carlsson3a31d602008-02-06 07:19:27 +0000182 return RValue::get(Result);
183 }
Eli Friedmanf4e85332008-05-27 15:32:46 +0000184 case Builtin::BI__builtin_clz:
185 case Builtin::BI__builtin_clzl:
186 case Builtin::BI__builtin_clzll: {
187 Value *ArgValue = EmitScalarExpr(E->getArg(0));
Mike Stump1eb44332009-09-09 15:08:12 +0000188
Eli Friedmanf4e85332008-05-27 15:32:46 +0000189 const llvm::Type *ArgType = ArgValue->getType();
190 Value *F = CGM.getIntrinsic(Intrinsic::ctlz, &ArgType, 1);
191
Mike Stump1eb44332009-09-09 15:08:12 +0000192 const llvm::Type *ResultType = ConvertType(E->getType());
Eli Friedmanf4e85332008-05-27 15:32:46 +0000193 Value *Result = Builder.CreateCall(F, ArgValue, "tmp");
194 if (Result->getType() != ResultType)
Duncan Sandseac73e52009-11-16 13:11:21 +0000195 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
196 "cast");
Eli Friedmanf4e85332008-05-27 15:32:46 +0000197 return RValue::get(Result);
198 }
Daniel Dunbar04b29002008-07-21 17:19:41 +0000199 case Builtin::BI__builtin_ffs:
200 case Builtin::BI__builtin_ffsl:
201 case Builtin::BI__builtin_ffsll: {
202 // ffs(x) -> x ? cttz(x) + 1 : 0
203 Value *ArgValue = EmitScalarExpr(E->getArg(0));
Mike Stump1eb44332009-09-09 15:08:12 +0000204
Daniel Dunbar04b29002008-07-21 17:19:41 +0000205 const llvm::Type *ArgType = ArgValue->getType();
206 Value *F = CGM.getIntrinsic(Intrinsic::cttz, &ArgType, 1);
Mike Stump1eb44332009-09-09 15:08:12 +0000207
Daniel Dunbar04b29002008-07-21 17:19:41 +0000208 const llvm::Type *ResultType = ConvertType(E->getType());
Mike Stump1eb44332009-09-09 15:08:12 +0000209 Value *Tmp = Builder.CreateAdd(Builder.CreateCall(F, ArgValue, "tmp"),
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000210 llvm::ConstantInt::get(ArgType, 1), "tmp");
Owen Andersonc9c88b42009-07-31 20:28:54 +0000211 Value *Zero = llvm::Constant::getNullValue(ArgType);
Daniel Dunbar04b29002008-07-21 17:19:41 +0000212 Value *IsZero = Builder.CreateICmpEQ(ArgValue, Zero, "iszero");
213 Value *Result = Builder.CreateSelect(IsZero, Zero, Tmp, "ffs");
214 if (Result->getType() != ResultType)
Duncan Sandseac73e52009-11-16 13:11:21 +0000215 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
216 "cast");
Daniel Dunbar04b29002008-07-21 17:19:41 +0000217 return RValue::get(Result);
218 }
219 case Builtin::BI__builtin_parity:
220 case Builtin::BI__builtin_parityl:
221 case Builtin::BI__builtin_parityll: {
222 // parity(x) -> ctpop(x) & 1
223 Value *ArgValue = EmitScalarExpr(E->getArg(0));
Mike Stump1eb44332009-09-09 15:08:12 +0000224
Daniel Dunbar04b29002008-07-21 17:19:41 +0000225 const llvm::Type *ArgType = ArgValue->getType();
226 Value *F = CGM.getIntrinsic(Intrinsic::ctpop, &ArgType, 1);
Mike Stump1eb44332009-09-09 15:08:12 +0000227
Daniel Dunbar04b29002008-07-21 17:19:41 +0000228 const llvm::Type *ResultType = ConvertType(E->getType());
229 Value *Tmp = Builder.CreateCall(F, ArgValue, "tmp");
Mike Stump1eb44332009-09-09 15:08:12 +0000230 Value *Result = Builder.CreateAnd(Tmp, llvm::ConstantInt::get(ArgType, 1),
Daniel Dunbar04b29002008-07-21 17:19:41 +0000231 "tmp");
232 if (Result->getType() != ResultType)
Duncan Sandseac73e52009-11-16 13:11:21 +0000233 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
234 "cast");
Daniel Dunbar04b29002008-07-21 17:19:41 +0000235 return RValue::get(Result);
236 }
237 case Builtin::BI__builtin_popcount:
238 case Builtin::BI__builtin_popcountl:
239 case Builtin::BI__builtin_popcountll: {
240 Value *ArgValue = EmitScalarExpr(E->getArg(0));
Mike Stump1eb44332009-09-09 15:08:12 +0000241
Daniel Dunbar04b29002008-07-21 17:19:41 +0000242 const llvm::Type *ArgType = ArgValue->getType();
243 Value *F = CGM.getIntrinsic(Intrinsic::ctpop, &ArgType, 1);
Mike Stump1eb44332009-09-09 15:08:12 +0000244
Daniel Dunbar04b29002008-07-21 17:19:41 +0000245 const llvm::Type *ResultType = ConvertType(E->getType());
246 Value *Result = Builder.CreateCall(F, ArgValue, "tmp");
247 if (Result->getType() != ResultType)
Duncan Sandseac73e52009-11-16 13:11:21 +0000248 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
249 "cast");
Daniel Dunbar04b29002008-07-21 17:19:41 +0000250 return RValue::get(Result);
251 }
Chris Lattner1feedd82007-12-13 07:34:23 +0000252 case Builtin::BI__builtin_expect:
Daniel Dunbara933c3c2008-07-21 18:44:41 +0000253 // FIXME: pass expect through to LLVM
Chris Lattner1feedd82007-12-13 07:34:23 +0000254 return RValue::get(EmitScalarExpr(E->getArg(0)));
Anders Carlssondf4852a2007-12-02 21:58:10 +0000255 case Builtin::BI__builtin_bswap32:
256 case Builtin::BI__builtin_bswap64: {
Chris Lattner1feedd82007-12-13 07:34:23 +0000257 Value *ArgValue = EmitScalarExpr(E->getArg(0));
Anders Carlssondf4852a2007-12-02 21:58:10 +0000258 const llvm::Type *ArgType = ArgValue->getType();
Chris Lattner7acda7c2007-12-18 00:25:38 +0000259 Value *F = CGM.getIntrinsic(Intrinsic::bswap, &ArgType, 1);
Chris Lattner1feedd82007-12-13 07:34:23 +0000260 return RValue::get(Builder.CreateCall(F, ArgValue, "tmp"));
Mike Stump1eb44332009-09-09 15:08:12 +0000261 }
Daniel Dunbard5f8a4f2008-09-03 21:13:56 +0000262 case Builtin::BI__builtin_object_size: {
Mike Stumpb16d32f2009-10-26 23:39:48 +0000263 // We pass this builtin onto the optimizer so that it can
264 // figure out the object size in more complex cases.
Mike Stumpc4c90452009-10-27 22:09:17 +0000265 const llvm::Type *ResType[] = {
266 ConvertType(E->getType())
267 };
Eric Christopherfee667f2009-12-23 03:49:37 +0000268
269 // LLVM only supports 0 and 2, make sure that we pass along that
270 // as a boolean.
271 Value *Ty = EmitScalarExpr(E->getArg(1));
272 ConstantInt *CI = dyn_cast<ConstantInt>(Ty);
273 assert(CI);
274 uint64_t val = CI->getZExtValue();
275 CI = ConstantInt::get(llvm::Type::getInt1Ty(VMContext), (val & 0x2) >> 1);
276
Mike Stumpc4c90452009-10-27 22:09:17 +0000277 Value *F = CGM.getIntrinsic(Intrinsic::objectsize, ResType, 1);
278 return RValue::get(Builder.CreateCall2(F,
279 EmitScalarExpr(E->getArg(0)),
Eric Christopherfee667f2009-12-23 03:49:37 +0000280 CI));
Daniel Dunbard5f8a4f2008-09-03 21:13:56 +0000281 }
Daniel Dunbar4493f792008-07-21 22:59:13 +0000282 case Builtin::BI__builtin_prefetch: {
283 Value *Locality, *RW, *Address = EmitScalarExpr(E->getArg(0));
284 // FIXME: Technically these constants should of type 'int', yes?
Mike Stump1eb44332009-09-09 15:08:12 +0000285 RW = (E->getNumArgs() > 1) ? EmitScalarExpr(E->getArg(1)) :
Owen Anderson0032b272009-08-13 21:57:51 +0000286 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 0);
Mike Stump1eb44332009-09-09 15:08:12 +0000287 Locality = (E->getNumArgs() > 2) ? EmitScalarExpr(E->getArg(2)) :
Owen Anderson0032b272009-08-13 21:57:51 +0000288 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 3);
Daniel Dunbar4493f792008-07-21 22:59:13 +0000289 Value *F = CGM.getIntrinsic(Intrinsic::prefetch, 0, 0);
290 return RValue::get(Builder.CreateCall3(F, Address, RW, Locality));
Anders Carlssondf4852a2007-12-02 21:58:10 +0000291 }
Daniel Dunbar4493f792008-07-21 22:59:13 +0000292 case Builtin::BI__builtin_trap: {
293 Value *F = CGM.getIntrinsic(Intrinsic::trap, 0, 0);
294 return RValue::get(Builder.CreateCall(F));
295 }
Chris Lattner21190d52009-09-21 03:09:59 +0000296 case Builtin::BI__builtin_unreachable: {
Mike Stumpfba565d2009-12-16 03:07:12 +0000297 if (CatchUndefined && HaveInsertPoint())
298 EmitBranch(getTrapBB());
Chris Lattner21190d52009-09-21 03:09:59 +0000299 Value *V = Builder.CreateUnreachable();
300 Builder.ClearInsertionPoint();
301 return RValue::get(V);
302 }
303
Daniel Dunbara933c3c2008-07-21 18:44:41 +0000304 case Builtin::BI__builtin_powi:
305 case Builtin::BI__builtin_powif:
306 case Builtin::BI__builtin_powil: {
307 Value *Base = EmitScalarExpr(E->getArg(0));
308 Value *Exponent = EmitScalarExpr(E->getArg(1));
Daniel Dunbara933c3c2008-07-21 18:44:41 +0000309 const llvm::Type *ArgType = Base->getType();
310 Value *F = CGM.getIntrinsic(Intrinsic::powi, &ArgType, 1);
Daniel Dunbara933c3c2008-07-21 18:44:41 +0000311 return RValue::get(Builder.CreateCall2(F, Base, Exponent, "tmp"));
312 }
313
Chris Lattnerfe23e212007-12-20 00:44:32 +0000314 case Builtin::BI__builtin_isgreater:
315 case Builtin::BI__builtin_isgreaterequal:
316 case Builtin::BI__builtin_isless:
317 case Builtin::BI__builtin_islessequal:
318 case Builtin::BI__builtin_islessgreater:
319 case Builtin::BI__builtin_isunordered: {
320 // Ordered comparisons: we know the arguments to these are matching scalar
321 // floating point values.
Mike Stump1eb44332009-09-09 15:08:12 +0000322 Value *LHS = EmitScalarExpr(E->getArg(0));
Chris Lattnerfe23e212007-12-20 00:44:32 +0000323 Value *RHS = EmitScalarExpr(E->getArg(1));
Mike Stump1eb44332009-09-09 15:08:12 +0000324
Chris Lattnerfe23e212007-12-20 00:44:32 +0000325 switch (BuiltinID) {
326 default: assert(0 && "Unknown ordered comparison");
327 case Builtin::BI__builtin_isgreater:
328 LHS = Builder.CreateFCmpOGT(LHS, RHS, "cmp");
329 break;
330 case Builtin::BI__builtin_isgreaterequal:
331 LHS = Builder.CreateFCmpOGE(LHS, RHS, "cmp");
332 break;
333 case Builtin::BI__builtin_isless:
334 LHS = Builder.CreateFCmpOLT(LHS, RHS, "cmp");
335 break;
336 case Builtin::BI__builtin_islessequal:
337 LHS = Builder.CreateFCmpOLE(LHS, RHS, "cmp");
338 break;
339 case Builtin::BI__builtin_islessgreater:
340 LHS = Builder.CreateFCmpONE(LHS, RHS, "cmp");
341 break;
Mike Stump1eb44332009-09-09 15:08:12 +0000342 case Builtin::BI__builtin_isunordered:
Chris Lattnerfe23e212007-12-20 00:44:32 +0000343 LHS = Builder.CreateFCmpUNO(LHS, RHS, "cmp");
344 break;
345 }
346 // ZExt bool to int type.
347 return RValue::get(Builder.CreateZExt(LHS, ConvertType(E->getType()),
348 "tmp"));
349 }
Eli Friedmand6139892009-09-01 04:19:44 +0000350 case Builtin::BI__builtin_isnan: {
351 Value *V = EmitScalarExpr(E->getArg(0));
352 V = Builder.CreateFCmpUNO(V, V, "cmp");
353 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType()), "tmp"));
354 }
Chris Lattner420b1182010-05-06 05:35:16 +0000355
356 case Builtin::BI__builtin_isinf: {
357 // isinf(x) --> fabs(x) == infinity
358 Value *V = EmitScalarExpr(E->getArg(0));
359 V = EmitFAbs(*this, V, E->getArg(0)->getType());
360
361 V = Builder.CreateFCmpOEQ(V, ConstantFP::getInfinity(V->getType()),"isinf");
362 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType()), "tmp"));
363 }
Chris Lattner58ae5b42010-05-06 06:13:53 +0000364
365 // TODO: BI__builtin_isinf_sign
366 // isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0
Benjamin Kramer6349ce92010-05-19 11:24:26 +0000367
368 case Builtin::BI__builtin_isnormal: {
369 // isnormal(x) --> x == x && fabsf(x) < infinity && fabsf(x) >= float_min
370 Value *V = EmitScalarExpr(E->getArg(0));
371 Value *Eq = Builder.CreateFCmpOEQ(V, V, "iseq");
372
373 Value *Abs = EmitFAbs(*this, V, E->getArg(0)->getType());
374 Value *IsLessThanInf =
375 Builder.CreateFCmpULT(Abs, ConstantFP::getInfinity(V->getType()),"isinf");
376 APFloat Smallest = APFloat::getSmallestNormalized(
377 getContext().getFloatTypeSemantics(E->getArg(0)->getType()));
378 Value *IsNormal =
379 Builder.CreateFCmpUGE(Abs, ConstantFP::get(V->getContext(), Smallest),
380 "isnormal");
381 V = Builder.CreateAnd(Eq, IsLessThanInf, "and");
382 V = Builder.CreateAnd(V, IsNormal, "and");
383 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
384 }
385
Chris Lattnered074152010-05-06 06:04:13 +0000386 case Builtin::BI__builtin_isfinite: {
387 // isfinite(x) --> x == x && fabs(x) != infinity; }
388 Value *V = EmitScalarExpr(E->getArg(0));
389 Value *Eq = Builder.CreateFCmpOEQ(V, V, "iseq");
390
391 Value *Abs = EmitFAbs(*this, V, E->getArg(0)->getType());
392 Value *IsNotInf =
393 Builder.CreateFCmpUNE(Abs, ConstantFP::getInfinity(V->getType()),"isinf");
394
395 V = Builder.CreateAnd(Eq, IsNotInf, "and");
396 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
397 }
398
Eli Friedmanb52fe9c2009-06-02 07:10:30 +0000399 case Builtin::BIalloca:
Chris Lattner9e800e32008-06-16 17:15:14 +0000400 case Builtin::BI__builtin_alloca: {
Chris Lattner9e800e32008-06-16 17:15:14 +0000401 Value *Size = EmitScalarExpr(E->getArg(0));
Owen Anderson0032b272009-08-13 21:57:51 +0000402 return RValue::get(Builder.CreateAlloca(llvm::Type::getInt8Ty(VMContext), Size, "tmp"));
Daniel Dunbar1caae952008-07-22 00:26:45 +0000403 }
Eli Friedmane6dddfd2010-01-23 19:00:10 +0000404 case Builtin::BIbzero:
Daniel Dunbar1caae952008-07-22 00:26:45 +0000405 case Builtin::BI__builtin_bzero: {
406 Value *Address = EmitScalarExpr(E->getArg(0));
Mon P Wang3ecd7852010-04-04 03:10:52 +0000407 Value *SizeVal = EmitScalarExpr(E->getArg(1));
408 Builder.CreateCall5(CGM.getMemSetFn(Address->getType(), SizeVal->getType()),
409 Address,
410 llvm::ConstantInt::get(llvm::Type::getInt8Ty(VMContext), 0),
411 SizeVal,
412 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 1),
413 llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), 0));
Daniel Dunbar1caae952008-07-22 00:26:45 +0000414 return RValue::get(Address);
Chris Lattner9e800e32008-06-16 17:15:14 +0000415 }
Eli Friedmane6ec2052009-12-17 00:14:28 +0000416 case Builtin::BImemcpy:
Eli Friedmand4b32e42008-05-19 23:27:48 +0000417 case Builtin::BI__builtin_memcpy: {
Daniel Dunbar1caae952008-07-22 00:26:45 +0000418 Value *Address = EmitScalarExpr(E->getArg(0));
Mon P Wang3ecd7852010-04-04 03:10:52 +0000419 Value *SrcAddr = EmitScalarExpr(E->getArg(1));
420 Value *SizeVal = EmitScalarExpr(E->getArg(2));
421 Builder.CreateCall5(CGM.getMemCpyFn(Address->getType(), SrcAddr->getType(),
422 SizeVal->getType()),
423 Address, SrcAddr, SizeVal,
424 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 1),
425 llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), 0));
Daniel Dunbar1caae952008-07-22 00:26:45 +0000426 return RValue::get(Address);
427 }
Eli Friedmane6ec2052009-12-17 00:14:28 +0000428 case Builtin::BImemmove:
Daniel Dunbar1caae952008-07-22 00:26:45 +0000429 case Builtin::BI__builtin_memmove: {
430 Value *Address = EmitScalarExpr(E->getArg(0));
Mon P Wang3ecd7852010-04-04 03:10:52 +0000431 Value *SrcAddr = EmitScalarExpr(E->getArg(1));
432 Value *SizeVal = EmitScalarExpr(E->getArg(2));
433 Builder.CreateCall5(CGM.getMemMoveFn(Address->getType(), SrcAddr->getType(),
434 SizeVal->getType()),
435 Address, SrcAddr, SizeVal,
436 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 1),
437 llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), 0));
Daniel Dunbar1caae952008-07-22 00:26:45 +0000438 return RValue::get(Address);
439 }
Eli Friedmane6ec2052009-12-17 00:14:28 +0000440 case Builtin::BImemset:
Daniel Dunbar1caae952008-07-22 00:26:45 +0000441 case Builtin::BI__builtin_memset: {
442 Value *Address = EmitScalarExpr(E->getArg(0));
Mon P Wang3ecd7852010-04-04 03:10:52 +0000443 Value *SizeVal = EmitScalarExpr(E->getArg(2));
444 Builder.CreateCall5(CGM.getMemSetFn(Address->getType(), SizeVal->getType()),
445 Address,
446 Builder.CreateTrunc(EmitScalarExpr(E->getArg(1)),
447 llvm::Type::getInt8Ty(VMContext)),
448 SizeVal,
449 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 1),
450 llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), 0));
Daniel Dunbar1caae952008-07-22 00:26:45 +0000451 return RValue::get(Address);
Eli Friedmand4b32e42008-05-19 23:27:48 +0000452 }
John McCallfb17a562010-03-03 10:30:05 +0000453 case Builtin::BI__builtin_dwarf_cfa: {
454 // The offset in bytes from the first argument to the CFA.
455 //
456 // Why on earth is this in the frontend? Is there any reason at
457 // all that the backend can't reasonably determine this while
458 // lowering llvm.eh.dwarf.cfa()?
459 //
460 // TODO: If there's a satisfactory reason, add a target hook for
461 // this instead of hard-coding 0, which is correct for most targets.
462 int32_t Offset = 0;
463
464 Value *F = CGM.getIntrinsic(Intrinsic::eh_dwarf_cfa, 0, 0);
465 return RValue::get(Builder.CreateCall(F, getInt32(VMContext, Offset)));
466 }
Eli Friedman256f77e2008-05-20 08:59:34 +0000467 case Builtin::BI__builtin_return_address: {
Anton Korobeynikov83c2a982009-12-27 14:27:22 +0000468 Value *Depth = EmitScalarExpr(E->getArg(0));
469 Depth = Builder.CreateIntCast(Depth,
470 llvm::Type::getInt32Ty(VMContext),
471 false, "tmp");
Eli Friedman256f77e2008-05-20 08:59:34 +0000472 Value *F = CGM.getIntrinsic(Intrinsic::returnaddress, 0, 0);
Anton Korobeynikov83c2a982009-12-27 14:27:22 +0000473 return RValue::get(Builder.CreateCall(F, Depth));
Eli Friedman256f77e2008-05-20 08:59:34 +0000474 }
475 case Builtin::BI__builtin_frame_address: {
Anton Korobeynikov83c2a982009-12-27 14:27:22 +0000476 Value *Depth = EmitScalarExpr(E->getArg(0));
477 Depth = Builder.CreateIntCast(Depth,
478 llvm::Type::getInt32Ty(VMContext),
479 false, "tmp");
Eli Friedman256f77e2008-05-20 08:59:34 +0000480 Value *F = CGM.getIntrinsic(Intrinsic::frameaddress, 0, 0);
Anton Korobeynikov83c2a982009-12-27 14:27:22 +0000481 return RValue::get(Builder.CreateCall(F, Depth));
Eli Friedman256f77e2008-05-20 08:59:34 +0000482 }
Eli Friedman3b660ef2009-05-03 19:23:23 +0000483 case Builtin::BI__builtin_extract_return_addr: {
John McCall492c4f92010-03-03 04:15:11 +0000484 Value *Address = EmitScalarExpr(E->getArg(0));
485 Value *Result = getTargetHooks().decodeReturnAddress(*this, Address);
486 return RValue::get(Result);
487 }
488 case Builtin::BI__builtin_frob_return_addr: {
489 Value *Address = EmitScalarExpr(E->getArg(0));
490 Value *Result = getTargetHooks().encodeReturnAddress(*this, Address);
491 return RValue::get(Result);
Eli Friedman3b660ef2009-05-03 19:23:23 +0000492 }
John McCall6374c332010-03-06 00:35:14 +0000493 case Builtin::BI__builtin_dwarf_sp_column: {
494 const llvm::IntegerType *Ty
495 = cast<llvm::IntegerType>(ConvertType(E->getType()));
496 int Column = getTargetHooks().getDwarfEHStackPointer(CGM);
497 if (Column == -1) {
498 CGM.ErrorUnsupported(E, "__builtin_dwarf_sp_column");
499 return RValue::get(llvm::UndefValue::get(Ty));
500 }
501 return RValue::get(llvm::ConstantInt::get(Ty, Column, true));
502 }
503 case Builtin::BI__builtin_init_dwarf_reg_size_table: {
504 Value *Address = EmitScalarExpr(E->getArg(0));
505 if (getTargetHooks().initDwarfEHRegSizeTable(*this, Address))
506 CGM.ErrorUnsupported(E, "__builtin_init_dwarf_reg_size_table");
507 return RValue::get(llvm::UndefValue::get(ConvertType(E->getType())));
508 }
John McCall7ada1112010-03-03 05:38:58 +0000509 case Builtin::BI__builtin_eh_return: {
510 Value *Int = EmitScalarExpr(E->getArg(0));
511 Value *Ptr = EmitScalarExpr(E->getArg(1));
512
513 const llvm::IntegerType *IntTy = cast<llvm::IntegerType>(Int->getType());
514 assert((IntTy->getBitWidth() == 32 || IntTy->getBitWidth() == 64) &&
515 "LLVM's __builtin_eh_return only supports 32- and 64-bit variants");
516 Value *F = CGM.getIntrinsic(IntTy->getBitWidth() == 32
517 ? Intrinsic::eh_return_i32
518 : Intrinsic::eh_return_i64,
519 0, 0);
520 Builder.CreateCall2(F, Int, Ptr);
521 Value *V = Builder.CreateUnreachable();
522 Builder.ClearInsertionPoint();
523 return RValue::get(V);
524 }
Eli Friedmana6d75c02009-06-02 09:37:50 +0000525 case Builtin::BI__builtin_unwind_init: {
526 Value *F = CGM.getIntrinsic(Intrinsic::eh_unwind_init, 0, 0);
527 return RValue::get(Builder.CreateCall(F));
528 }
John McCall5e110852010-03-02 02:31:24 +0000529 case Builtin::BI__builtin_extend_pointer: {
530 // Extends a pointer to the size of an _Unwind_Word, which is
John McCalld0b76ca2010-03-02 03:50:12 +0000531 // uint64_t on all platforms. Generally this gets poked into a
532 // register and eventually used as an address, so if the
533 // addressing registers are wider than pointers and the platform
534 // doesn't implicitly ignore high-order bits when doing
535 // addressing, we need to make sure we zext / sext based on
536 // the platform's expectations.
John McCall5e110852010-03-02 02:31:24 +0000537 //
538 // See: http://gcc.gnu.org/ml/gcc-bugs/2002-02/msg00237.html
John McCalld0b76ca2010-03-02 03:50:12 +0000539
540 LLVMContext &C = CGM.getLLVMContext();
541
542 // Cast the pointer to intptr_t.
John McCall5e110852010-03-02 02:31:24 +0000543 Value *Ptr = EmitScalarExpr(E->getArg(0));
John McCalld0b76ca2010-03-02 03:50:12 +0000544 const llvm::IntegerType *IntPtrTy = CGM.getTargetData().getIntPtrType(C);
545 Value *Result = Builder.CreatePtrToInt(Ptr, IntPtrTy, "extend.cast");
546
547 // If that's 64 bits, we're done.
548 if (IntPtrTy->getBitWidth() == 64)
549 return RValue::get(Result);
550
551 // Otherwise, ask the codegen data what to do.
552 const llvm::IntegerType *Int64Ty = llvm::IntegerType::get(C, 64);
John McCall492c4f92010-03-03 04:15:11 +0000553 if (getTargetHooks().extendPointerWithSExt())
John McCalld0b76ca2010-03-02 03:50:12 +0000554 return RValue::get(Builder.CreateSExt(Result, Int64Ty, "extend.sext"));
555 else
556 return RValue::get(Builder.CreateZExt(Result, Int64Ty, "extend.zext"));
John McCall5e110852010-03-02 02:31:24 +0000557 }
Eli Friedmana6d75c02009-06-02 09:37:50 +0000558 case Builtin::BI__builtin_setjmp: {
John McCall78673d92010-05-27 18:47:06 +0000559 // Buffer is a void**.
Eli Friedmana6d75c02009-06-02 09:37:50 +0000560 Value *Buf = EmitScalarExpr(E->getArg(0));
John McCall78673d92010-05-27 18:47:06 +0000561
562 // Store the frame pointer to the setjmp buffer.
Eli Friedmana6d75c02009-06-02 09:37:50 +0000563 Value *FrameAddr =
John McCall78673d92010-05-27 18:47:06 +0000564 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::frameaddress),
565 ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 0));
Eli Friedmana6d75c02009-06-02 09:37:50 +0000566 Builder.CreateStore(FrameAddr, Buf);
John McCall78673d92010-05-27 18:47:06 +0000567
Jim Grosbach6d172e22010-05-27 23:54:20 +0000568 // Store the stack pointer to the setjmp buffer.
569 Value *StackAddr =
570 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::stacksave));
571 Value *StackSaveSlot =
572 Builder.CreateGEP(Buf, ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
573 2));
574 Builder.CreateStore(StackAddr, StackSaveSlot);
575
John McCall78673d92010-05-27 18:47:06 +0000576 // Call LLVM's EH setjmp, which is lightweight.
577 Value *F = CGM.getIntrinsic(Intrinsic::eh_sjlj_setjmp);
578 Buf = Builder.CreateBitCast(Buf, llvm::Type::getInt8PtrTy(VMContext));
Eli Friedmana6d75c02009-06-02 09:37:50 +0000579 return RValue::get(Builder.CreateCall(F, Buf));
580 }
581 case Builtin::BI__builtin_longjmp: {
Eli Friedmana6d75c02009-06-02 09:37:50 +0000582 Value *Buf = EmitScalarExpr(E->getArg(0));
John McCall78673d92010-05-27 18:47:06 +0000583 Buf = Builder.CreateBitCast(Buf, llvm::Type::getInt8PtrTy(VMContext));
584
585 // Call LLVM's EH longjmp, which is lightweight.
586 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::eh_sjlj_longjmp), Buf);
587
588 // longjmp doesn't return; mark this as unreachable
589 Value *V = Builder.CreateUnreachable();
590 Builder.ClearInsertionPoint();
591 return RValue::get(V);
Eli Friedmana6d75c02009-06-02 09:37:50 +0000592 }
Mon P Wang1ffe2812008-05-09 22:40:52 +0000593 case Builtin::BI__sync_fetch_and_add:
Mon P Wang1ffe2812008-05-09 22:40:52 +0000594 case Builtin::BI__sync_fetch_and_sub:
Chris Lattner5caa3702009-05-08 06:58:22 +0000595 case Builtin::BI__sync_fetch_and_or:
596 case Builtin::BI__sync_fetch_and_and:
597 case Builtin::BI__sync_fetch_and_xor:
598 case Builtin::BI__sync_add_and_fetch:
599 case Builtin::BI__sync_sub_and_fetch:
600 case Builtin::BI__sync_and_and_fetch:
601 case Builtin::BI__sync_or_and_fetch:
602 case Builtin::BI__sync_xor_and_fetch:
603 case Builtin::BI__sync_val_compare_and_swap:
604 case Builtin::BI__sync_bool_compare_and_swap:
605 case Builtin::BI__sync_lock_test_and_set:
606 case Builtin::BI__sync_lock_release:
607 assert(0 && "Shouldn't make it through sema");
608 case Builtin::BI__sync_fetch_and_add_1:
609 case Builtin::BI__sync_fetch_and_add_2:
610 case Builtin::BI__sync_fetch_and_add_4:
611 case Builtin::BI__sync_fetch_and_add_8:
612 case Builtin::BI__sync_fetch_and_add_16:
613 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_add, E);
614 case Builtin::BI__sync_fetch_and_sub_1:
615 case Builtin::BI__sync_fetch_and_sub_2:
616 case Builtin::BI__sync_fetch_and_sub_4:
617 case Builtin::BI__sync_fetch_and_sub_8:
618 case Builtin::BI__sync_fetch_and_sub_16:
Mon P Wang09b6bf52008-06-25 08:21:36 +0000619 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_sub, E);
Chris Lattner5caa3702009-05-08 06:58:22 +0000620 case Builtin::BI__sync_fetch_and_or_1:
621 case Builtin::BI__sync_fetch_and_or_2:
622 case Builtin::BI__sync_fetch_and_or_4:
623 case Builtin::BI__sync_fetch_and_or_8:
624 case Builtin::BI__sync_fetch_and_or_16:
625 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_or, E);
626 case Builtin::BI__sync_fetch_and_and_1:
627 case Builtin::BI__sync_fetch_and_and_2:
628 case Builtin::BI__sync_fetch_and_and_4:
629 case Builtin::BI__sync_fetch_and_and_8:
630 case Builtin::BI__sync_fetch_and_and_16:
631 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_and, E);
632 case Builtin::BI__sync_fetch_and_xor_1:
633 case Builtin::BI__sync_fetch_and_xor_2:
634 case Builtin::BI__sync_fetch_and_xor_4:
635 case Builtin::BI__sync_fetch_and_xor_8:
636 case Builtin::BI__sync_fetch_and_xor_16:
637 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_xor, E);
Mike Stump1eb44332009-09-09 15:08:12 +0000638
Chris Lattner5caa3702009-05-08 06:58:22 +0000639 // Clang extensions: not overloaded yet.
Mon P Wang1ffe2812008-05-09 22:40:52 +0000640 case Builtin::BI__sync_fetch_and_min:
641 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_min, E);
642 case Builtin::BI__sync_fetch_and_max:
643 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_max, E);
644 case Builtin::BI__sync_fetch_and_umin:
645 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_umin, E);
646 case Builtin::BI__sync_fetch_and_umax:
647 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_umax, E);
Daniel Dunbar0002d232009-04-07 00:55:51 +0000648
Chris Lattner5caa3702009-05-08 06:58:22 +0000649 case Builtin::BI__sync_add_and_fetch_1:
650 case Builtin::BI__sync_add_and_fetch_2:
651 case Builtin::BI__sync_add_and_fetch_4:
652 case Builtin::BI__sync_add_and_fetch_8:
653 case Builtin::BI__sync_add_and_fetch_16:
Mike Stump1eb44332009-09-09 15:08:12 +0000654 return EmitBinaryAtomicPost(*this, Intrinsic::atomic_load_add, E,
Daniel Dunbar0002d232009-04-07 00:55:51 +0000655 llvm::Instruction::Add);
Chris Lattner5caa3702009-05-08 06:58:22 +0000656 case Builtin::BI__sync_sub_and_fetch_1:
657 case Builtin::BI__sync_sub_and_fetch_2:
658 case Builtin::BI__sync_sub_and_fetch_4:
659 case Builtin::BI__sync_sub_and_fetch_8:
660 case Builtin::BI__sync_sub_and_fetch_16:
Daniel Dunbar0002d232009-04-07 00:55:51 +0000661 return EmitBinaryAtomicPost(*this, Intrinsic::atomic_load_sub, E,
662 llvm::Instruction::Sub);
Chris Lattner5caa3702009-05-08 06:58:22 +0000663 case Builtin::BI__sync_and_and_fetch_1:
664 case Builtin::BI__sync_and_and_fetch_2:
665 case Builtin::BI__sync_and_and_fetch_4:
666 case Builtin::BI__sync_and_and_fetch_8:
667 case Builtin::BI__sync_and_and_fetch_16:
Daniel Dunbar0002d232009-04-07 00:55:51 +0000668 return EmitBinaryAtomicPost(*this, Intrinsic::atomic_load_and, E,
669 llvm::Instruction::And);
Chris Lattner5caa3702009-05-08 06:58:22 +0000670 case Builtin::BI__sync_or_and_fetch_1:
671 case Builtin::BI__sync_or_and_fetch_2:
672 case Builtin::BI__sync_or_and_fetch_4:
673 case Builtin::BI__sync_or_and_fetch_8:
674 case Builtin::BI__sync_or_and_fetch_16:
Daniel Dunbar0002d232009-04-07 00:55:51 +0000675 return EmitBinaryAtomicPost(*this, Intrinsic::atomic_load_or, E,
676 llvm::Instruction::Or);
Chris Lattner5caa3702009-05-08 06:58:22 +0000677 case Builtin::BI__sync_xor_and_fetch_1:
678 case Builtin::BI__sync_xor_and_fetch_2:
679 case Builtin::BI__sync_xor_and_fetch_4:
680 case Builtin::BI__sync_xor_and_fetch_8:
681 case Builtin::BI__sync_xor_and_fetch_16:
Daniel Dunbar0002d232009-04-07 00:55:51 +0000682 return EmitBinaryAtomicPost(*this, Intrinsic::atomic_load_xor, E,
683 llvm::Instruction::Xor);
Mike Stump1eb44332009-09-09 15:08:12 +0000684
Chris Lattner5caa3702009-05-08 06:58:22 +0000685 case Builtin::BI__sync_val_compare_and_swap_1:
686 case Builtin::BI__sync_val_compare_and_swap_2:
687 case Builtin::BI__sync_val_compare_and_swap_4:
688 case Builtin::BI__sync_val_compare_and_swap_8:
Daniel Dunbarcb61a7b2010-03-20 07:04:11 +0000689 case Builtin::BI__sync_val_compare_and_swap_16: {
Mon P Wangc5004512008-07-31 03:28:23 +0000690 const llvm::Type *ResType[2];
691 ResType[0]= ConvertType(E->getType());
692 ResType[1] = ConvertType(E->getArg(0)->getType());
693 Value *AtomF = CGM.getIntrinsic(Intrinsic::atomic_cmp_swap, ResType, 2);
Daniel Dunbarcb61a7b2010-03-20 07:04:11 +0000694 Value *Args[3] = { EmitScalarExpr(E->getArg(0)),
695 EmitScalarExpr(E->getArg(1)),
696 EmitScalarExpr(E->getArg(2)) };
697 return RValue::get(EmitCallWithBarrier(*this, AtomF, Args, Args + 3));
Anders Carlsson89799cf2007-10-29 02:59:40 +0000698 }
Daniel Dunbar0002d232009-04-07 00:55:51 +0000699
Chris Lattner5caa3702009-05-08 06:58:22 +0000700 case Builtin::BI__sync_bool_compare_and_swap_1:
701 case Builtin::BI__sync_bool_compare_and_swap_2:
702 case Builtin::BI__sync_bool_compare_and_swap_4:
703 case Builtin::BI__sync_bool_compare_and_swap_8:
Daniel Dunbarcb61a7b2010-03-20 07:04:11 +0000704 case Builtin::BI__sync_bool_compare_and_swap_16: {
Daniel Dunbar0002d232009-04-07 00:55:51 +0000705 const llvm::Type *ResType[2];
Chris Lattner5caa3702009-05-08 06:58:22 +0000706 ResType[0]= ConvertType(E->getArg(1)->getType());
Owen Anderson96e0fc72009-07-29 22:16:19 +0000707 ResType[1] = llvm::PointerType::getUnqual(ResType[0]);
Daniel Dunbar0002d232009-04-07 00:55:51 +0000708 Value *AtomF = CGM.getIntrinsic(Intrinsic::atomic_cmp_swap, ResType, 2);
709 Value *OldVal = EmitScalarExpr(E->getArg(1));
Daniel Dunbarcb61a7b2010-03-20 07:04:11 +0000710 Value *Args[3] = { EmitScalarExpr(E->getArg(0)),
711 OldVal,
712 EmitScalarExpr(E->getArg(2)) };
713 Value *PrevVal = EmitCallWithBarrier(*this, AtomF, Args, Args + 3);
Daniel Dunbar0002d232009-04-07 00:55:51 +0000714 Value *Result = Builder.CreateICmpEQ(PrevVal, OldVal);
715 // zext bool to int.
716 return RValue::get(Builder.CreateZExt(Result, ConvertType(E->getType())));
717 }
718
Chris Lattner5caa3702009-05-08 06:58:22 +0000719 case Builtin::BI__sync_lock_test_and_set_1:
720 case Builtin::BI__sync_lock_test_and_set_2:
721 case Builtin::BI__sync_lock_test_and_set_4:
722 case Builtin::BI__sync_lock_test_and_set_8:
723 case Builtin::BI__sync_lock_test_and_set_16:
Nate Begeman7ea2e3f2008-05-15 07:38:03 +0000724 return EmitBinaryAtomic(*this, Intrinsic::atomic_swap, E);
Daniel Dunbarcb61a7b2010-03-20 07:04:11 +0000725
Chris Lattner5caa3702009-05-08 06:58:22 +0000726 case Builtin::BI__sync_lock_release_1:
727 case Builtin::BI__sync_lock_release_2:
728 case Builtin::BI__sync_lock_release_4:
729 case Builtin::BI__sync_lock_release_8:
Chris Lattnerf58cd9b2009-05-13 04:46:13 +0000730 case Builtin::BI__sync_lock_release_16: {
731 Value *Ptr = EmitScalarExpr(E->getArg(0));
732 const llvm::Type *ElTy =
733 cast<llvm::PointerType>(Ptr->getType())->getElementType();
Daniel Dunbar007b5672009-11-29 21:11:47 +0000734 llvm::StoreInst *Store =
735 Builder.CreateStore(llvm::Constant::getNullValue(ElTy), Ptr);
736 Store->setVolatile(true);
Daniel Dunbareb4f81e2009-05-27 23:45:33 +0000737 return RValue::get(0);
Chris Lattnerf58cd9b2009-05-13 04:46:13 +0000738 }
Daniel Dunbaref2abfe2009-02-16 22:43:43 +0000739
Chris Lattnerf58cd9b2009-05-13 04:46:13 +0000740 case Builtin::BI__sync_synchronize: {
Daniel Dunbarcb61a7b2010-03-20 07:04:11 +0000741 // We assume like gcc appears to, that this only applies to cached memory.
742 EmitMemoryBarrier(*this, true, true, true, true, false);
Daniel Dunbareb4f81e2009-05-27 23:45:33 +0000743 return RValue::get(0);
Chris Lattnerf58cd9b2009-05-13 04:46:13 +0000744 }
Mike Stump1eb44332009-09-09 15:08:12 +0000745
Tanya Lattner0b571642010-01-16 01:21:14 +0000746 case Builtin::BI__builtin_llvm_memory_barrier: {
747 Value *C[5] = {
748 EmitScalarExpr(E->getArg(0)),
749 EmitScalarExpr(E->getArg(1)),
750 EmitScalarExpr(E->getArg(2)),
751 EmitScalarExpr(E->getArg(3)),
752 EmitScalarExpr(E->getArg(4))
753 };
754 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::memory_barrier), C, C + 5);
755 return RValue::get(0);
756 }
757
Daniel Dunbaref2abfe2009-02-16 22:43:43 +0000758 // Library functions with special handling.
Daniel Dunbaref2abfe2009-02-16 22:43:43 +0000759 case Builtin::BIsqrt:
760 case Builtin::BIsqrtf:
761 case Builtin::BIsqrtl: {
John McCallbeb41282010-04-07 08:20:20 +0000762 // TODO: there is currently no set of optimizer flags
763 // sufficient for us to rewrite sqrt to @llvm.sqrt.
764 // -fmath-errno=0 is not good enough; we need finiteness.
765 // We could probably precondition the call with an ult
766 // against 0, but is that worth the complexity?
767 break;
Daniel Dunbaref2abfe2009-02-16 22:43:43 +0000768 }
769
770 case Builtin::BIpow:
771 case Builtin::BIpowf:
772 case Builtin::BIpowl: {
773 // Rewrite sqrt to intrinsic if allowed.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000774 if (!FD->hasAttr<ConstAttr>())
Daniel Dunbaref2abfe2009-02-16 22:43:43 +0000775 break;
776 Value *Base = EmitScalarExpr(E->getArg(0));
777 Value *Exponent = EmitScalarExpr(E->getArg(1));
778 const llvm::Type *ArgType = Base->getType();
779 Value *F = CGM.getIntrinsic(Intrinsic::pow, &ArgType, 1);
780 return RValue::get(Builder.CreateCall2(F, Base, Exponent, "tmp"));
781 }
Eli Friedmanba68b082010-03-06 02:17:52 +0000782
783 case Builtin::BI__builtin_signbit:
784 case Builtin::BI__builtin_signbitf:
785 case Builtin::BI__builtin_signbitl: {
786 LLVMContext &C = CGM.getLLVMContext();
787
788 Value *Arg = EmitScalarExpr(E->getArg(0));
789 const llvm::Type *ArgTy = Arg->getType();
790 if (ArgTy->isPPC_FP128Ty())
791 break; // FIXME: I'm not sure what the right implementation is here.
792 int ArgWidth = ArgTy->getPrimitiveSizeInBits();
793 const llvm::Type *ArgIntTy = llvm::IntegerType::get(C, ArgWidth);
794 Value *BCArg = Builder.CreateBitCast(Arg, ArgIntTy);
795 Value *ZeroCmp = llvm::Constant::getNullValue(ArgIntTy);
796 Value *Result = Builder.CreateICmpSLT(BCArg, ZeroCmp);
797 return RValue::get(Builder.CreateZExt(Result, ConvertType(E->getType())));
798 }
Nate Begeman7ea2e3f2008-05-15 07:38:03 +0000799 }
Mike Stump1eb44332009-09-09 15:08:12 +0000800
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000801 // If this is an alias for a libm function (e.g. __builtin_sin) turn it into
802 // that function.
Douglas Gregor3e41d602009-02-13 23:20:09 +0000803 if (getContext().BuiltinInfo.isLibFunction(BuiltinID) ||
804 getContext().BuiltinInfo.isPredefinedLibFunction(BuiltinID))
Anders Carlsson31777a22009-12-24 19:08:58 +0000805 return EmitCall(E->getCallee()->getType(),
806 CGM.getBuiltinLibFunction(FD, BuiltinID),
Anders Carlssond2490a92009-12-24 20:40:36 +0000807 ReturnValueSlot(),
Anders Carlsson31777a22009-12-24 19:08:58 +0000808 E->arg_begin(), E->arg_end());
Mike Stump1eb44332009-09-09 15:08:12 +0000809
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000810 // See if we have a target specific intrinsic.
Dale Johannesena6f80ef2009-02-05 01:50:47 +0000811 const char *Name = getContext().BuiltinInfo.GetName(BuiltinID);
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +0000812 Intrinsic::ID IntrinsicID = Intrinsic::not_intrinsic;
813 if (const char *Prefix =
Mike Stump1eb44332009-09-09 15:08:12 +0000814 llvm::Triple::getArchTypePrefix(Target.getTriple().getArch()))
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +0000815 IntrinsicID = Intrinsic::getIntrinsicForGCCBuiltin(Prefix, Name);
Mike Stump1eb44332009-09-09 15:08:12 +0000816
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000817 if (IntrinsicID != Intrinsic::not_intrinsic) {
818 SmallVector<Value*, 16> Args;
Mike Stump1eb44332009-09-09 15:08:12 +0000819
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000820 Function *F = CGM.getIntrinsic(IntrinsicID);
821 const llvm::FunctionType *FTy = F->getFunctionType();
Mike Stump1eb44332009-09-09 15:08:12 +0000822
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000823 for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
824 Value *ArgValue = EmitScalarExpr(E->getArg(i));
Mike Stump1eb44332009-09-09 15:08:12 +0000825
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000826 // If the intrinsic arg type is different from the builtin arg type
827 // we need to do a bit cast.
828 const llvm::Type *PTy = FTy->getParamType(i);
829 if (PTy != ArgValue->getType()) {
830 assert(PTy->canLosslesslyBitCastTo(FTy->getParamType(i)) &&
831 "Must be able to losslessly bit cast to param");
832 ArgValue = Builder.CreateBitCast(ArgValue, PTy);
833 }
Mike Stump1eb44332009-09-09 15:08:12 +0000834
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000835 Args.push_back(ArgValue);
836 }
Mike Stump1eb44332009-09-09 15:08:12 +0000837
Jay Foadbeaaccd2009-05-21 09:52:38 +0000838 Value *V = Builder.CreateCall(F, Args.data(), Args.data() + Args.size());
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000839 QualType BuiltinRetType = E->getType();
Mike Stump1eb44332009-09-09 15:08:12 +0000840
Owen Anderson0032b272009-08-13 21:57:51 +0000841 const llvm::Type *RetTy = llvm::Type::getVoidTy(VMContext);
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000842 if (!BuiltinRetType->isVoidType()) RetTy = ConvertType(BuiltinRetType);
Mike Stump1eb44332009-09-09 15:08:12 +0000843
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000844 if (RetTy != V->getType()) {
845 assert(V->getType()->canLosslesslyBitCastTo(RetTy) &&
846 "Must be able to losslessly bit cast result type");
847 V = Builder.CreateBitCast(V, RetTy);
848 }
Mike Stump1eb44332009-09-09 15:08:12 +0000849
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000850 return RValue::get(V);
851 }
Mike Stump1eb44332009-09-09 15:08:12 +0000852
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000853 // See if we have a target specific builtin that needs to be lowered.
Daniel Dunbarf02e9dd2008-10-10 00:24:54 +0000854 if (Value *V = EmitTargetBuiltinExpr(BuiltinID, E))
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000855 return RValue::get(V);
Mike Stump1eb44332009-09-09 15:08:12 +0000856
Daniel Dunbar488e9932008-08-16 00:56:44 +0000857 ErrorUnsupported(E, "builtin function");
Mike Stump1eb44332009-09-09 15:08:12 +0000858
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000859 // Unknown builtin, for now just dump it out and return undef.
860 if (hasAggregateLLVMType(E->getType()))
Daniel Dunbar195337d2010-02-09 02:48:28 +0000861 return RValue::getAggregate(CreateMemTemp(E->getType()));
Owen Anderson03e20502009-07-30 23:11:26 +0000862 return RValue::get(llvm::UndefValue::get(ConvertType(E->getType())));
Mike Stump1eb44332009-09-09 15:08:12 +0000863}
Anders Carlsson564f1de2007-12-09 23:17:02 +0000864
Daniel Dunbarf02e9dd2008-10-10 00:24:54 +0000865Value *CodeGenFunction::EmitTargetBuiltinExpr(unsigned BuiltinID,
866 const CallExpr *E) {
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +0000867 switch (Target.getTriple().getArch()) {
Chris Lattner2752c012010-03-03 19:03:45 +0000868 case llvm::Triple::arm:
869 case llvm::Triple::thumb:
870 return EmitARMBuiltinExpr(BuiltinID, E);
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +0000871 case llvm::Triple::x86:
872 case llvm::Triple::x86_64:
Daniel Dunbarf02e9dd2008-10-10 00:24:54 +0000873 return EmitX86BuiltinExpr(BuiltinID, E);
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +0000874 case llvm::Triple::ppc:
875 case llvm::Triple::ppc64:
Daniel Dunbarf02e9dd2008-10-10 00:24:54 +0000876 return EmitPPCBuiltinExpr(BuiltinID, E);
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +0000877 default:
878 return 0;
879 }
Daniel Dunbarf02e9dd2008-10-10 00:24:54 +0000880}
881
Nate Begeman998622c2010-06-07 16:01:56 +0000882const llvm::Type *GetNeonType(LLVMContext &Ctx, unsigned type, bool q) {
883 switch (type) {
884 default: break;
885 case 0:
886 case 5: return llvm::VectorType::get(llvm::Type::getInt8Ty(Ctx), 8 << q);
887 case 6:
888 case 7:
889 case 1: return llvm::VectorType::get(llvm::Type::getInt16Ty(Ctx), 4 << q);
890 case 2: return llvm::VectorType::get(llvm::Type::getInt32Ty(Ctx), 2 << q);
891 case 3: return llvm::VectorType::get(llvm::Type::getInt64Ty(Ctx), 1 << q);
892 case 4: return llvm::VectorType::get(llvm::Type::getFloatTy(Ctx), 2 << q);
893 };
894 return 0;
895}
896
Nate Begeman30d91712010-06-08 06:03:01 +0000897Value *CodeGenFunction::EmitNeonCall(Function *F, SmallVectorImpl<Value*> &Ops,
898 const char *name) {
899 unsigned j = 0;
900 for (Function::const_arg_iterator ai = F->arg_begin(), ae = F->arg_end();
901 ai != ae; ++ai, ++j)
902 Ops[j] = Builder.CreateBitCast(Ops[j], ai->getType(), name);
903
904 return Builder.CreateCall(F, Ops.begin(), Ops.end(), name);
905}
906
Chris Lattner2752c012010-03-03 19:03:45 +0000907Value *CodeGenFunction::EmitARMBuiltinExpr(unsigned BuiltinID,
908 const CallExpr *E) {
Nate Begeman998622c2010-06-07 16:01:56 +0000909 llvm::SmallVector<Value*, 4> Ops;
Nate Begeman30d91712010-06-08 06:03:01 +0000910 bool usgn, quad, poly, half;
Nate Begeman998622c2010-06-07 16:01:56 +0000911 const llvm::Type *Ty;
912 unsigned Int;
913
914 // Determine the type of this overloaded NEON intrinsic.
Nate Begeman30d91712010-06-08 06:03:01 +0000915 if (BuiltinID > ARM::BI__builtin_thread_pointer) {
Nate Begeman998622c2010-06-07 16:01:56 +0000916 for (unsigned i = 0, e = E->getNumArgs() - 1; i != e; i++)
917 Ops.push_back(EmitScalarExpr(E->getArg(i)));
918
919 llvm::APSInt Result;
920 const Expr *Arg = E->getArg(E->getNumArgs()-1);
921 if (!Arg->isIntegerConstantExpr(Result, getContext()))
922 return 0;
923
924 unsigned type = Result.getZExtValue();
Nate Begeman998622c2010-06-07 16:01:56 +0000925 usgn = type & 0x08;
Nate Begeman30d91712010-06-08 06:03:01 +0000926 quad = type & 0x10;
Nate Begeman998622c2010-06-07 16:01:56 +0000927 poly = type == 5 || type == 6;
928 half = type == 7;
Nate Begeman30d91712010-06-08 06:03:01 +0000929
930 Ty = GetNeonType(VMContext, type & 0x7, quad);
931 if (!Ty)
932 return 0;
Nate Begeman998622c2010-06-07 16:01:56 +0000933 }
934
Chris Lattner2752c012010-03-03 19:03:45 +0000935 switch (BuiltinID) {
936 default: return 0;
Rafael Espindola79ba5092010-06-07 17:26:50 +0000937 case ARM::BI__clear_cache: {
938 const FunctionDecl *FD = E->getDirectCallee();
939 Value *a = EmitScalarExpr(E->getArg(0));
940 Value *b = EmitScalarExpr(E->getArg(1));
941 const llvm::Type *Ty = CGM.getTypes().ConvertType(FD->getType());
942 const llvm::FunctionType *FTy = cast<llvm::FunctionType>(Ty);
943 llvm::StringRef Name = FD->getName();
944 return Builder.CreateCall2(CGM.CreateRuntimeFunction(FTy, Name),
945 a, b);
Chris Lattner2752c012010-03-03 19:03:45 +0000946 }
Nate Begeman998622c2010-06-07 16:01:56 +0000947 case ARM::BI__builtin_neon_vaba_v:
Nate Begeman30d91712010-06-08 06:03:01 +0000948 case ARM::BI__builtin_neon_vabaq_v:
Nate Begeman998622c2010-06-07 16:01:56 +0000949 Int = usgn ? Intrinsic::arm_neon_vabau : Intrinsic::arm_neon_vabas;
Nate Begeman30d91712010-06-08 06:03:01 +0000950 return EmitNeonCall(CGM.getIntrinsic(Int, &Ty, 1), Ops, "vaba");
951 case ARM::BI__builtin_neon_vabal_v:
Nate Begeman998622c2010-06-07 16:01:56 +0000952 Int = usgn ? Intrinsic::arm_neon_vabalu : Intrinsic::arm_neon_vabals;
Nate Begeman30d91712010-06-08 06:03:01 +0000953 return EmitNeonCall(CGM.getIntrinsic(Int, &Ty, 1), Ops, "vabal");
Nate Begeman998622c2010-06-07 16:01:56 +0000954 case ARM::BI__builtin_neon_vabd_v:
Nate Begeman30d91712010-06-08 06:03:01 +0000955 case ARM::BI__builtin_neon_vabdq_v:
Nate Begeman998622c2010-06-07 16:01:56 +0000956 Int = usgn ? Intrinsic::arm_neon_vabdu : Intrinsic::arm_neon_vabds;
Nate Begeman30d91712010-06-08 06:03:01 +0000957 return EmitNeonCall(CGM.getIntrinsic(Int, &Ty, 1), Ops, "vabd");
958 case ARM::BI__builtin_neon_vabdl_v:
Nate Begeman998622c2010-06-07 16:01:56 +0000959 Int = usgn ? Intrinsic::arm_neon_vabdlu : Intrinsic::arm_neon_vabdls;
Nate Begeman30d91712010-06-08 06:03:01 +0000960 return EmitNeonCall(CGM.getIntrinsic(Int, &Ty, 1), Ops, "vabdl");
Nate Begeman998622c2010-06-07 16:01:56 +0000961 case ARM::BI__builtin_neon_vabs_v:
962 case ARM::BI__builtin_neon_vabsq_v: {
Nate Begeman30d91712010-06-08 06:03:01 +0000963 Function *F = CGM.getIntrinsic(Intrinsic::arm_neon_vabs, &Ty, 1);
964 return EmitNeonCall(F, Ops, "vabs");
Nate Begeman998622c2010-06-07 16:01:56 +0000965 }
966 case ARM::BI__builtin_neon_vaddhn_v: {
Nate Begeman30d91712010-06-08 06:03:01 +0000967 Function *F = CGM.getIntrinsic(Intrinsic::arm_neon_vaddhn, &Ty, 1);
968 return EmitNeonCall(F, Ops, "vaddhn");
Nate Begeman998622c2010-06-07 16:01:56 +0000969 }
Nate Begeman30d91712010-06-08 06:03:01 +0000970 case ARM::BI__builtin_neon_vaddl_v:
Nate Begeman998622c2010-06-07 16:01:56 +0000971 Int = usgn ? Intrinsic::arm_neon_vaddlu : Intrinsic::arm_neon_vaddls;
Nate Begeman30d91712010-06-08 06:03:01 +0000972 return EmitNeonCall(CGM.getIntrinsic(Int, &Ty, 1), Ops, "vaddl");
973 case ARM::BI__builtin_neon_vaddw_v:
Nate Begeman998622c2010-06-07 16:01:56 +0000974 Int = usgn ? Intrinsic::arm_neon_vaddws : Intrinsic::arm_neon_vaddwu;
Nate Begeman30d91712010-06-08 06:03:01 +0000975 return EmitNeonCall(CGM.getIntrinsic(Int, &Ty, 1), Ops, "vaddw");
Nate Begeman9eb65a52010-06-08 00:17:19 +0000976 // FIXME: vbsl -> or ((0 & 1), (0 & 2)) in arm_neon.h
977 case ARM::BI__builtin_neon_vcale_v:
978 std::swap(Ops[0], Ops[1]);
Nate Begeman30d91712010-06-08 06:03:01 +0000979 case ARM::BI__builtin_neon_vcage_v: {
980 Function *F = CGM.getIntrinsic(Intrinsic::arm_neon_vacged, &Ty, 1);
981 return EmitNeonCall(F, Ops, "vcage");
982 }
Nate Begeman9eb65a52010-06-08 00:17:19 +0000983 case ARM::BI__builtin_neon_vcaleq_v:
984 std::swap(Ops[0], Ops[1]);
Nate Begeman30d91712010-06-08 06:03:01 +0000985 case ARM::BI__builtin_neon_vcageq_v: {
986 Function *F = CGM.getIntrinsic(Intrinsic::arm_neon_vacgeq, &Ty, 1);
987 return EmitNeonCall(F, Ops, "vcage");
988 }
Nate Begeman9eb65a52010-06-08 00:17:19 +0000989 case ARM::BI__builtin_neon_vcalt_v:
990 std::swap(Ops[0], Ops[1]);
Nate Begeman30d91712010-06-08 06:03:01 +0000991 case ARM::BI__builtin_neon_vcagt_v: {
992 Function *F = CGM.getIntrinsic(Intrinsic::arm_neon_vacgtd, &Ty, 1);
993 return EmitNeonCall(F, Ops, "vcagt");
994 }
Nate Begeman9eb65a52010-06-08 00:17:19 +0000995 case ARM::BI__builtin_neon_vcaltq_v:
996 std::swap(Ops[0], Ops[1]);
Nate Begeman30d91712010-06-08 06:03:01 +0000997 case ARM::BI__builtin_neon_vcagtq_v: {
998 Function *F = CGM.getIntrinsic(Intrinsic::arm_neon_vacgtq, &Ty, 1);
999 return EmitNeonCall(F, Ops, "vcagt");
1000 }
Nate Begeman9eb65a52010-06-08 00:17:19 +00001001 case ARM::BI__builtin_neon_vcls_v:
1002 case ARM::BI__builtin_neon_vclsq_v: {
Nate Begeman30d91712010-06-08 06:03:01 +00001003 Function *F = CGM.getIntrinsic(Intrinsic::arm_neon_vcls, &Ty, 1);
1004 return EmitNeonCall(F, Ops, "vcls");
Nate Begeman9eb65a52010-06-08 00:17:19 +00001005 }
1006 case ARM::BI__builtin_neon_vclz_v:
1007 case ARM::BI__builtin_neon_vclzq_v: {
Nate Begeman30d91712010-06-08 06:03:01 +00001008 Function *F = CGM.getIntrinsic(Intrinsic::arm_neon_vclz, &Ty, 1);
1009 return EmitNeonCall(F, Ops, "vclz");
Nate Begeman9eb65a52010-06-08 00:17:19 +00001010 }
1011 case ARM::BI__builtin_neon_vcnt_v:
1012 case ARM::BI__builtin_neon_vcntq_v: {
Nate Begeman30d91712010-06-08 06:03:01 +00001013 Function *F = CGM.getIntrinsic(Intrinsic::arm_neon_vcnt, &Ty, 1);
1014 return EmitNeonCall(F, Ops, "vcnt");
Nate Begeman9eb65a52010-06-08 00:17:19 +00001015 }
1016 // FIXME: intrinsics for f16<->f32 convert missing from ARM target.
1017 case ARM::BI__builtin_neon_vcvt_f32_v:
1018 case ARM::BI__builtin_neon_vcvtq_f32_v: {
Nate Begeman30d91712010-06-08 06:03:01 +00001019 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1020 Ty = GetNeonType(VMContext, 4, quad);
Nate Begeman9eb65a52010-06-08 00:17:19 +00001021 return usgn ? Builder.CreateUIToFP(Ops[0], Ty, "vcvt")
1022 : Builder.CreateSIToFP(Ops[0], Ty, "vcvt");
1023 }
1024 case ARM::BI__builtin_neon_vcvt_s32_v:
1025 case ARM::BI__builtin_neon_vcvt_u32_v:
1026 case ARM::BI__builtin_neon_vcvtq_s32_v:
1027 case ARM::BI__builtin_neon_vcvtq_u32_v: {
Nate Begeman30d91712010-06-08 06:03:01 +00001028 Ops[0] = Builder.CreateBitCast(Ops[0], GetNeonType(VMContext, 4, quad));
Nate Begeman9eb65a52010-06-08 00:17:19 +00001029 return usgn ? Builder.CreateFPToUI(Ops[0], Ty, "vcvt")
1030 : Builder.CreateFPToSI(Ops[0], Ty, "vcvt");
1031 }
Nate Begeman30d91712010-06-08 06:03:01 +00001032 // FIXME: these intrinsics often do not work due to the fragility of bitcasts
1033 // coming and going during codegen.
Nate Begeman9eb65a52010-06-08 00:17:19 +00001034 case ARM::BI__builtin_neon_vcvt_n_f32_v:
1035 case ARM::BI__builtin_neon_vcvtq_n_f32_v: {
Nate Begeman30d91712010-06-08 06:03:01 +00001036 const llvm::Type *Tys[2] = { GetNeonType(VMContext, 4, quad), Ty };
Nate Begeman9eb65a52010-06-08 00:17:19 +00001037 Int = usgn ? Intrinsic::arm_neon_vcvtfxu2fp : Intrinsic::arm_neon_vcvtfxs2fp;
Nate Begeman30d91712010-06-08 06:03:01 +00001038 Function *F = CGM.getIntrinsic(Int, Tys, 2);
1039 return EmitNeonCall(F, Ops, "vcvt_n");
Nate Begeman9eb65a52010-06-08 00:17:19 +00001040 }
1041 case ARM::BI__builtin_neon_vcvt_n_s32_v:
1042 case ARM::BI__builtin_neon_vcvt_n_u32_v:
1043 case ARM::BI__builtin_neon_vcvtq_n_s32_v:
1044 case ARM::BI__builtin_neon_vcvtq_n_u32_v: {
Nate Begeman30d91712010-06-08 06:03:01 +00001045 const llvm::Type *Tys[2] = { Ty, GetNeonType(VMContext, 4, quad) };
Nate Begeman9eb65a52010-06-08 00:17:19 +00001046 Int = usgn ? Intrinsic::arm_neon_vcvtfp2fxu : Intrinsic::arm_neon_vcvtfp2fxs;
Nate Begeman30d91712010-06-08 06:03:01 +00001047 Function *F = CGM.getIntrinsic(Int, Tys, 2);
1048 return EmitNeonCall(F, Ops, "vcvt_n");
1049 }
1050 case ARM::BI__builtin_neon_vext_v:
1051 case ARM::BI__builtin_neon_vextq_v: {
1052 ConstantInt *C = dyn_cast<ConstantInt>(Ops[2]);
1053 int CV = C->getSExtValue();
Nate Begeman30d91712010-06-08 06:03:01 +00001054 const llvm::Type *I32Ty = llvm::Type::getInt32Ty(VMContext);
Nate Begeman1c2a88c2010-06-09 01:10:23 +00001055
1056 SmallVector<Constant*, 16> Indices;
Nate Begeman30d91712010-06-08 06:03:01 +00001057 for (unsigned i = 0, e = cast<llvm::VectorType>(Ty)->getNumElements();
1058 i != e; ++i)
1059 Indices.push_back(ConstantInt::get(I32Ty, i+CV));
1060
1061 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1062 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
1063 Value* SV = llvm::ConstantVector::get(Indices.begin(), Indices.size());
Nate Begeman1c2a88c2010-06-09 01:10:23 +00001064 return Builder.CreateShuffleVector(Ops[0], Ops[1], SV, "vext");
1065 }
1066 case ARM::BI__builtin_neon_vtbl1_v:
1067 return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vtbl1),
1068 Ops, "vtbl1");
1069 case ARM::BI__builtin_neon_vtbl2_v:
1070 return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vtbl2),
1071 Ops, "vtbl2");
1072 case ARM::BI__builtin_neon_vtbl3_v:
1073 return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vtbl3),
1074 Ops, "vtbl3");
1075 case ARM::BI__builtin_neon_vtbl4_v:
1076 return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vtbl4),
1077 Ops, "vtbl4");
1078 case ARM::BI__builtin_neon_vtbx1_v:
1079 return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vtbx1),
1080 Ops, "vtbx1");
1081 case ARM::BI__builtin_neon_vtbx2_v:
1082 return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vtbx2),
1083 Ops, "vtbx2");
1084 case ARM::BI__builtin_neon_vtbx3_v:
1085 return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vtbx3),
1086 Ops, "vtbx3");
1087 case ARM::BI__builtin_neon_vtbx4_v:
1088 return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vtbx4),
1089 Ops, "vtbx4");
1090 case ARM::BI__builtin_neon_vtst_v:
1091 case ARM::BI__builtin_neon_vtstq_v: {
1092 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1093 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
1094 Ops[0] = Builder.CreateAnd(Ops[0], Ops[1]);
1095 Ops[0] = Builder.CreateICmp(ICmpInst::ICMP_NE, Ops[0],
1096 ConstantAggregateZero::get(Ty));
1097 return Builder.CreateSExt(Ops[0], Ty, "vtst");
1098 }
1099 // FIXME: transpose/zip/unzip don't currently match patterns for
1100 // the non-q variants, but emitting 2 shufflevectors seems like a hack.
1101 case ARM::BI__builtin_neon_vtrn_v:
1102 case ARM::BI__builtin_neon_vtrnq_v: {
1103 const llvm::Type *I32Ty = llvm::Type::getInt32Ty(VMContext);
1104 SmallVector<Constant*, 32> Indices;
1105 unsigned nElts = cast<llvm::VectorType>(Ty)->getNumElements();
1106 for (unsigned vi = 0; vi != 2; ++vi) {
1107 for (unsigned i = 0; i != nElts; i += 2) {
1108 Indices.push_back(ConstantInt::get(I32Ty, i+vi));
1109 Indices.push_back(ConstantInt::get(I32Ty, i+nElts+vi));
1110 }
1111 }
1112 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1113 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
1114 Value* SV = llvm::ConstantVector::get(Indices.begin(), Indices.size());
1115 return Builder.CreateShuffleVector(Ops[0], Ops[1], SV, "vtrn");
1116 }
1117 case ARM::BI__builtin_neon_vuzp_v:
1118 case ARM::BI__builtin_neon_vuzpq_v: {
1119 const llvm::Type *I32Ty = llvm::Type::getInt32Ty(VMContext);
1120 SmallVector<Constant*, 32> Indices;
1121 unsigned nElts = cast<llvm::VectorType>(Ty)->getNumElements();
1122 for (unsigned vi = 0; vi != 2; ++vi)
1123 for (unsigned i = 0; i != nElts; ++i)
1124 Indices.push_back(ConstantInt::get(I32Ty, 2*i+vi));
1125 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1126 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
1127 Value* SV = llvm::ConstantVector::get(Indices.begin(), Indices.size());
1128 return Builder.CreateShuffleVector(Ops[0], Ops[1], SV, "vuzp");
1129 }
1130 case ARM::BI__builtin_neon_vzip_v:
1131 case ARM::BI__builtin_neon_vzipq_v: {
1132 const llvm::Type *I32Ty = llvm::Type::getInt32Ty(VMContext);
1133 SmallVector<Constant*, 32> Indices;
1134 unsigned nElts = cast<llvm::VectorType>(Ty)->getNumElements();
1135 for (unsigned i = 0; i != nElts; ++i) {
1136 Indices.push_back(ConstantInt::get(I32Ty, i));
1137 Indices.push_back(ConstantInt::get(I32Ty, i+nElts));
1138 }
1139 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1140 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
1141 Value* SV = llvm::ConstantVector::get(Indices.begin(), Indices.size());
1142 return Builder.CreateShuffleVector(Ops[0], Ops[1], SV, "vzip");
Nate Begeman9eb65a52010-06-08 00:17:19 +00001143 }
Chris Lattner2752c012010-03-03 19:03:45 +00001144 }
1145}
1146
Mike Stump1eb44332009-09-09 15:08:12 +00001147Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
Chris Lattner1feedd82007-12-13 07:34:23 +00001148 const CallExpr *E) {
Mike Stump1eb44332009-09-09 15:08:12 +00001149
Anders Carlsson2929cfa2007-12-14 17:48:24 +00001150 llvm::SmallVector<Value*, 4> Ops;
1151
1152 for (unsigned i = 0, e = E->getNumArgs(); i != e; i++)
1153 Ops.push_back(EmitScalarExpr(E->getArg(i)));
1154
Anders Carlsson564f1de2007-12-09 23:17:02 +00001155 switch (BuiltinID) {
Anders Carlsson46a26b02007-12-09 23:39:18 +00001156 default: return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001157 case X86::BI__builtin_ia32_pslldi128:
Nate Begemane7722102008-04-14 04:49:57 +00001158 case X86::BI__builtin_ia32_psllqi128:
Mike Stump1eb44332009-09-09 15:08:12 +00001159 case X86::BI__builtin_ia32_psllwi128:
Nate Begemane7722102008-04-14 04:49:57 +00001160 case X86::BI__builtin_ia32_psradi128:
1161 case X86::BI__builtin_ia32_psrawi128:
1162 case X86::BI__builtin_ia32_psrldi128:
1163 case X86::BI__builtin_ia32_psrlqi128:
1164 case X86::BI__builtin_ia32_psrlwi128: {
Owen Anderson0032b272009-08-13 21:57:51 +00001165 Ops[1] = Builder.CreateZExt(Ops[1], llvm::Type::getInt64Ty(VMContext), "zext");
1166 const llvm::Type *Ty = llvm::VectorType::get(llvm::Type::getInt64Ty(VMContext), 2);
1167 llvm::Value *Zero = llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 0);
Owen Anderson03e20502009-07-30 23:11:26 +00001168 Ops[1] = Builder.CreateInsertElement(llvm::UndefValue::get(Ty),
Nate Begemane7722102008-04-14 04:49:57 +00001169 Ops[1], Zero, "insert");
1170 Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType(), "bitcast");
1171 const char *name = 0;
1172 Intrinsic::ID ID = Intrinsic::not_intrinsic;
Mike Stump1eb44332009-09-09 15:08:12 +00001173
Nate Begemane7722102008-04-14 04:49:57 +00001174 switch (BuiltinID) {
1175 default: assert(0 && "Unsupported shift intrinsic!");
1176 case X86::BI__builtin_ia32_pslldi128:
1177 name = "pslldi";
1178 ID = Intrinsic::x86_sse2_psll_d;
1179 break;
1180 case X86::BI__builtin_ia32_psllqi128:
1181 name = "psllqi";
1182 ID = Intrinsic::x86_sse2_psll_q;
1183 break;
1184 case X86::BI__builtin_ia32_psllwi128:
1185 name = "psllwi";
1186 ID = Intrinsic::x86_sse2_psll_w;
1187 break;
1188 case X86::BI__builtin_ia32_psradi128:
1189 name = "psradi";
1190 ID = Intrinsic::x86_sse2_psra_d;
1191 break;
1192 case X86::BI__builtin_ia32_psrawi128:
1193 name = "psrawi";
1194 ID = Intrinsic::x86_sse2_psra_w;
1195 break;
1196 case X86::BI__builtin_ia32_psrldi128:
1197 name = "psrldi";
1198 ID = Intrinsic::x86_sse2_psrl_d;
1199 break;
1200 case X86::BI__builtin_ia32_psrlqi128:
1201 name = "psrlqi";
1202 ID = Intrinsic::x86_sse2_psrl_q;
1203 break;
1204 case X86::BI__builtin_ia32_psrlwi128:
1205 name = "psrlwi";
1206 ID = Intrinsic::x86_sse2_psrl_w;
1207 break;
1208 }
1209 llvm::Function *F = CGM.getIntrinsic(ID);
Mike Stump1eb44332009-09-09 15:08:12 +00001210 return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);
Nate Begemane7722102008-04-14 04:49:57 +00001211 }
Mike Stump1eb44332009-09-09 15:08:12 +00001212 case X86::BI__builtin_ia32_pslldi:
Anders Carlsson2929cfa2007-12-14 17:48:24 +00001213 case X86::BI__builtin_ia32_psllqi:
Mike Stump1eb44332009-09-09 15:08:12 +00001214 case X86::BI__builtin_ia32_psllwi:
Anders Carlsson2929cfa2007-12-14 17:48:24 +00001215 case X86::BI__builtin_ia32_psradi:
1216 case X86::BI__builtin_ia32_psrawi:
1217 case X86::BI__builtin_ia32_psrldi:
1218 case X86::BI__builtin_ia32_psrlqi:
1219 case X86::BI__builtin_ia32_psrlwi: {
Owen Anderson0032b272009-08-13 21:57:51 +00001220 Ops[1] = Builder.CreateZExt(Ops[1], llvm::Type::getInt64Ty(VMContext), "zext");
1221 const llvm::Type *Ty = llvm::VectorType::get(llvm::Type::getInt64Ty(VMContext), 1);
Anders Carlsson2929cfa2007-12-14 17:48:24 +00001222 Ops[1] = Builder.CreateBitCast(Ops[1], Ty, "bitcast");
Anders Carlsson2929cfa2007-12-14 17:48:24 +00001223 const char *name = 0;
1224 Intrinsic::ID ID = Intrinsic::not_intrinsic;
Mike Stump1eb44332009-09-09 15:08:12 +00001225
Anders Carlsson2929cfa2007-12-14 17:48:24 +00001226 switch (BuiltinID) {
1227 default: assert(0 && "Unsupported shift intrinsic!");
1228 case X86::BI__builtin_ia32_pslldi:
1229 name = "pslldi";
1230 ID = Intrinsic::x86_mmx_psll_d;
1231 break;
1232 case X86::BI__builtin_ia32_psllqi:
1233 name = "psllqi";
1234 ID = Intrinsic::x86_mmx_psll_q;
1235 break;
1236 case X86::BI__builtin_ia32_psllwi:
1237 name = "psllwi";
1238 ID = Intrinsic::x86_mmx_psll_w;
1239 break;
1240 case X86::BI__builtin_ia32_psradi:
1241 name = "psradi";
1242 ID = Intrinsic::x86_mmx_psra_d;
1243 break;
1244 case X86::BI__builtin_ia32_psrawi:
1245 name = "psrawi";
1246 ID = Intrinsic::x86_mmx_psra_w;
1247 break;
1248 case X86::BI__builtin_ia32_psrldi:
1249 name = "psrldi";
1250 ID = Intrinsic::x86_mmx_psrl_d;
1251 break;
1252 case X86::BI__builtin_ia32_psrlqi:
1253 name = "psrlqi";
1254 ID = Intrinsic::x86_mmx_psrl_q;
1255 break;
1256 case X86::BI__builtin_ia32_psrlwi:
1257 name = "psrlwi";
1258 ID = Intrinsic::x86_mmx_psrl_w;
1259 break;
1260 }
Chris Lattner7acda7c2007-12-18 00:25:38 +00001261 llvm::Function *F = CGM.getIntrinsic(ID);
Mike Stump1eb44332009-09-09 15:08:12 +00001262 return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);
Anders Carlsson2929cfa2007-12-14 17:48:24 +00001263 }
Anders Carlsson79dcf5f2009-05-18 19:16:46 +00001264 case X86::BI__builtin_ia32_cmpps: {
1265 llvm::Function *F = CGM.getIntrinsic(Intrinsic::x86_sse_cmp_ps);
1266 return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), "cmpps");
1267 }
1268 case X86::BI__builtin_ia32_cmpss: {
1269 llvm::Function *F = CGM.getIntrinsic(Intrinsic::x86_sse_cmp_ss);
1270 return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), "cmpss");
Anders Carlssoncc8b7f92007-12-16 22:33:50 +00001271 }
Nate Begemane7722102008-04-14 04:49:57 +00001272 case X86::BI__builtin_ia32_ldmxcsr: {
Benjamin Kramer3c0ef8c2009-10-13 10:07:13 +00001273 const llvm::Type *PtrTy = llvm::Type::getInt8PtrTy(VMContext);
Owen Anderson0032b272009-08-13 21:57:51 +00001274 Value *One = llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 1);
1275 Value *Tmp = Builder.CreateAlloca(llvm::Type::getInt32Ty(VMContext), One, "tmp");
Nate Begemane7722102008-04-14 04:49:57 +00001276 Builder.CreateStore(Ops[0], Tmp);
1277 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_ldmxcsr),
Chris Lattner3eae03e2008-05-06 00:56:42 +00001278 Builder.CreateBitCast(Tmp, PtrTy));
Nate Begemane7722102008-04-14 04:49:57 +00001279 }
1280 case X86::BI__builtin_ia32_stmxcsr: {
Benjamin Kramer3c0ef8c2009-10-13 10:07:13 +00001281 const llvm::Type *PtrTy = llvm::Type::getInt8PtrTy(VMContext);
Owen Anderson0032b272009-08-13 21:57:51 +00001282 Value *One = llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 1);
1283 Value *Tmp = Builder.CreateAlloca(llvm::Type::getInt32Ty(VMContext), One, "tmp");
Nate Begemane7722102008-04-14 04:49:57 +00001284 One = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_stmxcsr),
Chris Lattner3eae03e2008-05-06 00:56:42 +00001285 Builder.CreateBitCast(Tmp, PtrTy));
Nate Begemane7722102008-04-14 04:49:57 +00001286 return Builder.CreateLoad(Tmp, "stmxcsr");
1287 }
Anders Carlsson79dcf5f2009-05-18 19:16:46 +00001288 case X86::BI__builtin_ia32_cmppd: {
1289 llvm::Function *F = CGM.getIntrinsic(Intrinsic::x86_sse2_cmp_pd);
1290 return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), "cmppd");
1291 }
1292 case X86::BI__builtin_ia32_cmpsd: {
1293 llvm::Function *F = CGM.getIntrinsic(Intrinsic::x86_sse2_cmp_sd);
1294 return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), "cmpsd");
Anders Carlssoncc8b7f92007-12-16 22:33:50 +00001295 }
Nate Begemane7722102008-04-14 04:49:57 +00001296 case X86::BI__builtin_ia32_storehps:
1297 case X86::BI__builtin_ia32_storelps: {
Owen Anderson0032b272009-08-13 21:57:51 +00001298 const llvm::Type *EltTy = llvm::Type::getInt64Ty(VMContext);
Owen Anderson96e0fc72009-07-29 22:16:19 +00001299 llvm::Type *PtrTy = llvm::PointerType::getUnqual(EltTy);
1300 llvm::Type *VecTy = llvm::VectorType::get(EltTy, 2);
Mike Stump1eb44332009-09-09 15:08:12 +00001301
Nate Begemane7722102008-04-14 04:49:57 +00001302 // cast val v2i64
1303 Ops[1] = Builder.CreateBitCast(Ops[1], VecTy, "cast");
Mike Stump1eb44332009-09-09 15:08:12 +00001304
Nate Begemane7722102008-04-14 04:49:57 +00001305 // extract (0, 1)
1306 unsigned Index = BuiltinID == X86::BI__builtin_ia32_storelps ? 0 : 1;
Owen Anderson0032b272009-08-13 21:57:51 +00001307 llvm::Value *Idx = llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), Index);
Nate Begemane7722102008-04-14 04:49:57 +00001308 Ops[1] = Builder.CreateExtractElement(Ops[1], Idx, "extract");
1309
1310 // cast pointer to i64 & store
1311 Ops[0] = Builder.CreateBitCast(Ops[0], PtrTy);
1312 return Builder.CreateStore(Ops[1], Ops[0]);
1313 }
Eric Christopher91b59272009-12-01 05:00:51 +00001314 case X86::BI__builtin_ia32_palignr: {
Eric Christophere57aa9e2010-04-15 01:43:08 +00001315 unsigned shiftVal = cast<llvm::ConstantInt>(Ops[2])->getZExtValue();
1316
1317 // If palignr is shifting the pair of input vectors less than 9 bytes,
1318 // emit a shuffle instruction.
1319 if (shiftVal <= 8) {
1320 const llvm::Type *IntTy = llvm::Type::getInt32Ty(VMContext);
1321
1322 llvm::SmallVector<llvm::Constant*, 8> Indices;
1323 for (unsigned i = 0; i != 8; ++i)
1324 Indices.push_back(llvm::ConstantInt::get(IntTy, shiftVal + i));
1325
1326 Value* SV = llvm::ConstantVector::get(Indices.begin(), Indices.size());
1327 return Builder.CreateShuffleVector(Ops[1], Ops[0], SV, "palignr");
1328 }
1329
1330 // If palignr is shifting the pair of input vectors more than 8 but less
1331 // than 16 bytes, emit a logical right shift of the destination.
1332 if (shiftVal < 16) {
1333 // MMX has these as 1 x i64 vectors for some odd optimization reasons.
1334 const llvm::Type *EltTy = llvm::Type::getInt64Ty(VMContext);
1335 const llvm::Type *VecTy = llvm::VectorType::get(EltTy, 1);
1336
1337 Ops[0] = Builder.CreateBitCast(Ops[0], VecTy, "cast");
1338 Ops[1] = llvm::ConstantInt::get(VecTy, (shiftVal-8) * 8);
1339
1340 // create i32 constant
1341 llvm::Function *F = CGM.getIntrinsic(Intrinsic::x86_mmx_psrl_q);
1342 return Builder.CreateCall(F, &Ops[0], &Ops[0] + 2, "palignr");
1343 }
1344
1345 // If palignr is shifting the pair of vectors more than 32 bytes, emit zero.
1346 return llvm::Constant::getNullValue(ConvertType(E->getType()));
Nate Begemanc3420ff2009-12-14 05:15:02 +00001347 }
1348 case X86::BI__builtin_ia32_palignr128: {
Nate Begemance5818a2009-12-14 04:57:03 +00001349 unsigned shiftVal = cast<llvm::ConstantInt>(Ops[2])->getZExtValue();
1350
1351 // If palignr is shifting the pair of input vectors less than 17 bytes,
1352 // emit a shuffle instruction.
1353 if (shiftVal <= 16) {
1354 const llvm::Type *IntTy = llvm::Type::getInt32Ty(VMContext);
1355
1356 llvm::SmallVector<llvm::Constant*, 16> Indices;
1357 for (unsigned i = 0; i != 16; ++i)
1358 Indices.push_back(llvm::ConstantInt::get(IntTy, shiftVal + i));
1359
1360 Value* SV = llvm::ConstantVector::get(Indices.begin(), Indices.size());
1361 return Builder.CreateShuffleVector(Ops[1], Ops[0], SV, "palignr");
1362 }
1363
1364 // If palignr is shifting the pair of input vectors more than 16 but less
1365 // than 32 bytes, emit a logical right shift of the destination.
1366 if (shiftVal < 32) {
1367 const llvm::Type *EltTy = llvm::Type::getInt64Ty(VMContext);
1368 const llvm::Type *VecTy = llvm::VectorType::get(EltTy, 2);
1369 const llvm::Type *IntTy = llvm::Type::getInt32Ty(VMContext);
1370
1371 Ops[0] = Builder.CreateBitCast(Ops[0], VecTy, "cast");
1372 Ops[1] = llvm::ConstantInt::get(IntTy, (shiftVal-16) * 8);
1373
1374 // create i32 constant
1375 llvm::Function *F = CGM.getIntrinsic(Intrinsic::x86_sse2_psrl_dq);
1376 return Builder.CreateCall(F, &Ops[0], &Ops[0] + 2, "palignr");
1377 }
1378
1379 // If palignr is shifting the pair of vectors more than 32 bytes, emit zero.
1380 return llvm::Constant::getNullValue(ConvertType(E->getType()));
Eric Christopher91b59272009-12-01 05:00:51 +00001381 }
Anders Carlsson564f1de2007-12-09 23:17:02 +00001382 }
1383}
1384
Mike Stump1eb44332009-09-09 15:08:12 +00001385Value *CodeGenFunction::EmitPPCBuiltinExpr(unsigned BuiltinID,
Chris Lattner1feedd82007-12-13 07:34:23 +00001386 const CallExpr *E) {
Chris Lattnerdd173942010-04-14 03:54:58 +00001387 llvm::SmallVector<Value*, 4> Ops;
1388
1389 for (unsigned i = 0, e = E->getNumArgs(); i != e; i++)
1390 Ops.push_back(EmitScalarExpr(E->getArg(i)));
1391
1392 Intrinsic::ID ID = Intrinsic::not_intrinsic;
1393
1394 switch (BuiltinID) {
1395 default: return 0;
1396
1397 // vec_st
1398 case PPC::BI__builtin_altivec_stvx:
1399 case PPC::BI__builtin_altivec_stvxl:
1400 case PPC::BI__builtin_altivec_stvebx:
1401 case PPC::BI__builtin_altivec_stvehx:
1402 case PPC::BI__builtin_altivec_stvewx:
1403 {
1404 Ops[2] = Builder.CreateBitCast(Ops[2], llvm::Type::getInt8PtrTy(VMContext));
1405 Ops[1] = !isa<Constant>(Ops[1]) || !cast<Constant>(Ops[1])->isNullValue()
1406 ? Builder.CreateGEP(Ops[2], Ops[1], "tmp") : Ops[2];
1407 Ops.pop_back();
1408
1409 switch (BuiltinID) {
1410 default: assert(0 && "Unsupported vavg intrinsic!");
1411 case PPC::BI__builtin_altivec_stvx:
1412 ID = Intrinsic::ppc_altivec_stvx;
1413 break;
1414 case PPC::BI__builtin_altivec_stvxl:
1415 ID = Intrinsic::ppc_altivec_stvxl;
1416 break;
1417 case PPC::BI__builtin_altivec_stvebx:
1418 ID = Intrinsic::ppc_altivec_stvebx;
1419 break;
1420 case PPC::BI__builtin_altivec_stvehx:
1421 ID = Intrinsic::ppc_altivec_stvehx;
1422 break;
1423 case PPC::BI__builtin_altivec_stvewx:
1424 ID = Intrinsic::ppc_altivec_stvewx;
1425 break;
1426 }
1427 llvm::Function *F = CGM.getIntrinsic(ID);
1428 return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), "");
1429 }
1430 }
Daniel Dunbarb0b84382009-12-18 20:58:47 +00001431 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001432}