blob: d186a7161971d6609f2978062f8f685c0045e9a7 [file] [log] [blame]
Anders Carlsson49865302007-08-20 18:05:56 +00001//===---- CGBuiltin.cpp - Emit LLVM Code for builtins ---------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner959e5be2007-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 Carlsson49865302007-08-20 18:05:56 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This contains code to emit Builtin calls as LLVM code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenFunction.h"
15#include "CodeGenModule.h"
Anders Carlsson6f6c6482007-12-09 21:20:04 +000016#include "clang/Basic/TargetInfo.h"
Chris Lattnerab862cc2007-08-31 04:31:45 +000017#include "clang/AST/ASTContext.h"
Anders Carlsson49865302007-08-20 18:05:56 +000018#include "clang/AST/Builtins.h"
19#include "clang/AST/Expr.h"
Anders Carlssone1449c12007-12-09 23:17:02 +000020#include "clang/AST/TargetBuiltins.h"
Chris Lattner783a78f2007-08-26 04:17:05 +000021#include "llvm/Constants.h"
Chris Lattner02c60f52007-08-31 04:44:06 +000022#include "llvm/Function.h"
Anders Carlssoncebb8d62007-10-12 23:56:29 +000023#include "llvm/Intrinsics.h"
Anders Carlsson49865302007-08-20 18:05:56 +000024using namespace clang;
25using namespace CodeGen;
Anders Carlsson6f6c6482007-12-09 21:20:04 +000026using namespace llvm;
27
Mon P Wangbf020f32008-05-09 22:40:52 +000028/// Utility to insert an atomic instruction based Instrinsic::ID and
29// the expression node
30static RValue EmitBinaryAtomic(CodeGenFunction& CFG,
31 Intrinsic::ID Id, const CallExpr *E) {
32 const llvm::Type *ResType = CFG.ConvertType(E->getType());
33 Value *AtomF = CFG.CGM.getIntrinsic(Id, &ResType, 1);
34 return RValue::get(CFG.Builder.CreateCall2(AtomF,
35 CFG.EmitScalarExpr(E->getArg(0)),
36 CFG.EmitScalarExpr(E->getArg(1))));
37}
38
Chris Lattner783a78f2007-08-26 04:17:05 +000039RValue CodeGenFunction::EmitBuiltinExpr(unsigned BuiltinID, const CallExpr *E) {
40 switch (BuiltinID) {
Chris Lattner2a674dc2008-06-30 18:32:54 +000041 default: break; // Handle intrinsics and libm functions below.
Anders Carlsson6f6c6482007-12-09 21:20:04 +000042
Chris Lattner783a78f2007-08-26 04:17:05 +000043 case Builtin::BI__builtin___CFStringMakeConstantString: {
44 const Expr *Arg = E->getArg(0);
45
Anders Carlsson783e1432007-11-01 00:39:26 +000046 while (1) {
47 if (const ParenExpr *PE = dyn_cast<ParenExpr>(Arg))
48 Arg = PE->getSubExpr();
49 else if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(Arg))
50 Arg = CE->getSubExpr();
51 else
52 break;
53 }
Chris Lattner783a78f2007-08-26 04:17:05 +000054
55 const StringLiteral *Literal = cast<StringLiteral>(Arg);
56 std::string S(Literal->getStrData(), Literal->getByteLength());
57
58 return RValue::get(CGM.GetAddrOfConstantCFString(S));
Anders Carlssoncebb8d62007-10-12 23:56:29 +000059 }
Chris Lattner08862322008-07-09 17:28:44 +000060 case Builtin::BI__builtin_stdarg_start:
Anders Carlssoncebb8d62007-10-12 23:56:29 +000061 case Builtin::BI__builtin_va_start:
62 case Builtin::BI__builtin_va_end: {
Chris Lattner9d37e132007-12-13 07:34:23 +000063 Value *ArgValue = EmitScalarExpr(E->getArg(0));
Christopher Lamb4fe5e702007-12-17 01:11:20 +000064 const llvm::Type *DestType =
65 llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
Anders Carlssoncebb8d62007-10-12 23:56:29 +000066 if (ArgValue->getType() != DestType)
67 ArgValue = Builder.CreateBitCast(ArgValue, DestType,
68 ArgValue->getNameStart());
69
Chris Lattner08862322008-07-09 17:28:44 +000070 Intrinsic::ID inst = (BuiltinID == Builtin::BI__builtin_va_end) ?
71 Intrinsic::vaend : Intrinsic::vastart;
Chris Lattner4b23f942007-12-18 00:25:38 +000072 return RValue::get(Builder.CreateCall(CGM.getIntrinsic(inst), ArgValue));
Anders Carlssoncebb8d62007-10-12 23:56:29 +000073 }
Anders Carlssond227c112008-02-09 20:26:43 +000074 case Builtin::BI__builtin_va_copy: {
75 // FIXME: This does not yet handle architectures where va_list is a struct.
76 Value *DstPtr = EmitScalarExpr(E->getArg(0));
77 Value *SrcValue = EmitScalarExpr(E->getArg(1));
78
79 Value *SrcPtr = CreateTempAlloca(SrcValue->getType(), "dst_ptr");
80
Anders Carlssond227c112008-02-09 20:26:43 +000081 Builder.CreateStore(SrcValue, SrcPtr, false);
82
83 const llvm::Type *Type =
84 llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
85
86 DstPtr = Builder.CreateBitCast(DstPtr, Type);
87 SrcPtr = Builder.CreateBitCast(SrcPtr, Type);
Chris Lattner7db5e942008-05-06 00:56:42 +000088 return RValue::get(Builder.CreateCall2(CGM.getIntrinsic(Intrinsic::vacopy),
89 DstPtr, SrcPtr));
Anders Carlssond227c112008-02-09 20:26:43 +000090 }
Anders Carlsson40438402007-10-29 02:59:40 +000091 case Builtin::BI__builtin_classify_type: {
Chris Lattner9d37e132007-12-13 07:34:23 +000092 APSInt Result(32);
Anders Carlsson40438402007-10-29 02:59:40 +000093 if (!E->isBuiltinClassifyType(Result))
94 assert(0 && "Expr not __builtin_classify_type!");
Chris Lattner9d37e132007-12-13 07:34:23 +000095 return RValue::get(ConstantInt::get(Result));
Anders Carlsson49865302007-08-20 18:05:56 +000096 }
Anders Carlsson783e1432007-11-01 00:39:26 +000097 case Builtin::BI__builtin_constant_p: {
Chris Lattner9d37e132007-12-13 07:34:23 +000098 APSInt Result(32);
Anders Carlsson783e1432007-11-01 00:39:26 +000099 // FIXME: Analyze the parameter and check if it is a constant.
100 Result = 0;
Chris Lattner9d37e132007-12-13 07:34:23 +0000101 return RValue::get(ConstantInt::get(Result));
Anders Carlsson783e1432007-11-01 00:39:26 +0000102 }
Anders Carlssone79dbe22007-11-20 19:05:17 +0000103 case Builtin::BI__builtin_abs: {
Chris Lattner9d37e132007-12-13 07:34:23 +0000104 Value *ArgValue = EmitScalarExpr(E->getArg(0));
Anders Carlssone79dbe22007-11-20 19:05:17 +0000105
106 llvm::BinaryOperator *NegOp =
107 Builder.CreateNeg(ArgValue, (ArgValue->getName() + "neg").c_str());
Chris Lattner9d37e132007-12-13 07:34:23 +0000108 Value *CmpResult =
Anders Carlssone79dbe22007-11-20 19:05:17 +0000109 Builder.CreateICmpSGE(ArgValue, NegOp->getOperand(0), "abscond");
Chris Lattner9d37e132007-12-13 07:34:23 +0000110 Value *Result =
Anders Carlssone79dbe22007-11-20 19:05:17 +0000111 Builder.CreateSelect(CmpResult, ArgValue, NegOp, "abs");
112
113 return RValue::get(Result);
114 }
Anders Carlssond50452e2008-02-06 07:19:27 +0000115 case Builtin::BI__builtin_ctz:
116 case Builtin::BI__builtin_ctzl:
117 case Builtin::BI__builtin_ctzll: {
118 Value *ArgValue = EmitScalarExpr(E->getArg(0));
119
120 const llvm::Type *ArgType = ArgValue->getType();
121 Value *F = CGM.getIntrinsic(Intrinsic::cttz, &ArgType, 1);
122
123 const llvm::Type *ResultType = ConvertType(E->getType());
124 Value *Result = Builder.CreateCall(F, ArgValue, "tmp");
125 if (Result->getType() != ResultType)
126 Result = Builder.CreateIntCast(Result, ResultType, "cast");
127 return RValue::get(Result);
128 }
Eli Friedmanecd15162008-05-27 15:32:46 +0000129 case Builtin::BI__builtin_clz:
130 case Builtin::BI__builtin_clzl:
131 case Builtin::BI__builtin_clzll: {
132 Value *ArgValue = EmitScalarExpr(E->getArg(0));
133
134 const llvm::Type *ArgType = ArgValue->getType();
135 Value *F = CGM.getIntrinsic(Intrinsic::ctlz, &ArgType, 1);
136
137 const llvm::Type *ResultType = ConvertType(E->getType());
138 Value *Result = Builder.CreateCall(F, ArgValue, "tmp");
139 if (Result->getType() != ResultType)
140 Result = Builder.CreateIntCast(Result, ResultType, "cast");
141 return RValue::get(Result);
142 }
Daniel Dunbar726f4d42008-07-21 17:19:41 +0000143 case Builtin::BI__builtin_ffs:
144 case Builtin::BI__builtin_ffsl:
145 case Builtin::BI__builtin_ffsll: {
146 // ffs(x) -> x ? cttz(x) + 1 : 0
147 Value *ArgValue = EmitScalarExpr(E->getArg(0));
148
149 const llvm::Type *ArgType = ArgValue->getType();
150 Value *F = CGM.getIntrinsic(Intrinsic::cttz, &ArgType, 1);
151
152 const llvm::Type *ResultType = ConvertType(E->getType());
153 Value *Tmp = Builder.CreateAdd(Builder.CreateCall(F, ArgValue, "tmp"),
154 ConstantInt::get(ArgType, 1), "tmp");
155 Value *Zero = llvm::Constant::getNullValue(ArgType);
156 Value *IsZero = Builder.CreateICmpEQ(ArgValue, Zero, "iszero");
157 Value *Result = Builder.CreateSelect(IsZero, Zero, Tmp, "ffs");
158 if (Result->getType() != ResultType)
159 Result = Builder.CreateIntCast(Result, ResultType, "cast");
160 return RValue::get(Result);
161 }
162 case Builtin::BI__builtin_parity:
163 case Builtin::BI__builtin_parityl:
164 case Builtin::BI__builtin_parityll: {
165 // parity(x) -> ctpop(x) & 1
166 Value *ArgValue = EmitScalarExpr(E->getArg(0));
167
168 const llvm::Type *ArgType = ArgValue->getType();
169 Value *F = CGM.getIntrinsic(Intrinsic::ctpop, &ArgType, 1);
170
171 const llvm::Type *ResultType = ConvertType(E->getType());
172 Value *Tmp = Builder.CreateCall(F, ArgValue, "tmp");
173 Value *Result = Builder.CreateAnd(Tmp, ConstantInt::get(ArgType, 1),
174 "tmp");
175 if (Result->getType() != ResultType)
176 Result = Builder.CreateIntCast(Result, ResultType, "cast");
177 return RValue::get(Result);
178 }
179 case Builtin::BI__builtin_popcount:
180 case Builtin::BI__builtin_popcountl:
181 case Builtin::BI__builtin_popcountll: {
182 Value *ArgValue = EmitScalarExpr(E->getArg(0));
183
184 const llvm::Type *ArgType = ArgValue->getType();
185 Value *F = CGM.getIntrinsic(Intrinsic::ctpop, &ArgType, 1);
186
187 const llvm::Type *ResultType = ConvertType(E->getType());
188 Value *Result = Builder.CreateCall(F, ArgValue, "tmp");
189 if (Result->getType() != ResultType)
190 Result = Builder.CreateIntCast(Result, ResultType, "cast");
191 return RValue::get(Result);
192 }
193
Chris Lattner9d37e132007-12-13 07:34:23 +0000194 case Builtin::BI__builtin_expect:
195 return RValue::get(EmitScalarExpr(E->getArg(0)));
Anders Carlsson56118002007-12-02 21:58:10 +0000196 case Builtin::BI__builtin_bswap32:
197 case Builtin::BI__builtin_bswap64: {
Chris Lattner9d37e132007-12-13 07:34:23 +0000198 Value *ArgValue = EmitScalarExpr(E->getArg(0));
Anders Carlsson56118002007-12-02 21:58:10 +0000199 const llvm::Type *ArgType = ArgValue->getType();
Chris Lattner4b23f942007-12-18 00:25:38 +0000200 Value *F = CGM.getIntrinsic(Intrinsic::bswap, &ArgType, 1);
Chris Lattner9d37e132007-12-13 07:34:23 +0000201 return RValue::get(Builder.CreateCall(F, ArgValue, "tmp"));
Anders Carlsson56118002007-12-02 21:58:10 +0000202 }
Anders Carlsson8fc5f602008-02-01 16:06:34 +0000203 case Builtin::BI__builtin_huge_val:
Daniel Dunbar726f4d42008-07-21 17:19:41 +0000204 case Builtin::BI__builtin_huge_valf:
205 case Builtin::BI__builtin_huge_vall:
Anders Carlssona8897f02007-12-05 07:22:48 +0000206 case Builtin::BI__builtin_inf:
Daniel Dunbar726f4d42008-07-21 17:19:41 +0000207 case Builtin::BI__builtin_inff:
Anders Carlssona8897f02007-12-05 07:22:48 +0000208 case Builtin::BI__builtin_infl: {
Chris Lattner2a674dc2008-06-30 18:32:54 +0000209 const llvm::fltSemantics &Sem =
210 CGM.getContext().getFloatTypeSemantics(E->getType());
211 return RValue::get(ConstantFP::get(APFloat::getInf(Sem)));
212 }
Chris Lattner2a674dc2008-06-30 18:32:54 +0000213 case Builtin::BI__builtin_nan:
Daniel Dunbar726f4d42008-07-21 17:19:41 +0000214 case Builtin::BI__builtin_nanf:
Chris Lattner2a674dc2008-06-30 18:32:54 +0000215 case Builtin::BI__builtin_nanl: {
216 // If this is __builtin_nan("") turn this into a simple nan, otherwise just
217 // call libm nan.
218 if (const StringLiteral *S =
219 dyn_cast<StringLiteral>(E->getArg(0)->IgnoreParenCasts())) {
220 if (!S->isWide() && S->getByteLength() == 0) { // empty string.
221 const llvm::fltSemantics &Sem =
222 CGM.getContext().getFloatTypeSemantics(E->getType());
223 return RValue::get(ConstantFP::get(APFloat::getNaN(Sem)));
224 }
225 }
226 // Otherwise, call libm 'nan'.
227 break;
Anders Carlssona8897f02007-12-05 07:22:48 +0000228 }
Chris Lattnerd1f26b32007-12-20 00:44:32 +0000229 case Builtin::BI__builtin_isgreater:
230 case Builtin::BI__builtin_isgreaterequal:
231 case Builtin::BI__builtin_isless:
232 case Builtin::BI__builtin_islessequal:
233 case Builtin::BI__builtin_islessgreater:
234 case Builtin::BI__builtin_isunordered: {
235 // Ordered comparisons: we know the arguments to these are matching scalar
236 // floating point values.
237 Value *LHS = EmitScalarExpr(E->getArg(0));
238 Value *RHS = EmitScalarExpr(E->getArg(1));
239
240 switch (BuiltinID) {
241 default: assert(0 && "Unknown ordered comparison");
242 case Builtin::BI__builtin_isgreater:
243 LHS = Builder.CreateFCmpOGT(LHS, RHS, "cmp");
244 break;
245 case Builtin::BI__builtin_isgreaterequal:
246 LHS = Builder.CreateFCmpOGE(LHS, RHS, "cmp");
247 break;
248 case Builtin::BI__builtin_isless:
249 LHS = Builder.CreateFCmpOLT(LHS, RHS, "cmp");
250 break;
251 case Builtin::BI__builtin_islessequal:
252 LHS = Builder.CreateFCmpOLE(LHS, RHS, "cmp");
253 break;
254 case Builtin::BI__builtin_islessgreater:
255 LHS = Builder.CreateFCmpONE(LHS, RHS, "cmp");
256 break;
257 case Builtin::BI__builtin_isunordered:
258 LHS = Builder.CreateFCmpUNO(LHS, RHS, "cmp");
259 break;
260 }
261 // ZExt bool to int type.
262 return RValue::get(Builder.CreateZExt(LHS, ConvertType(E->getType()),
263 "tmp"));
264 }
Chris Lattnere0c190a2008-06-16 17:15:14 +0000265 case Builtin::BI__builtin_alloca: {
266 // FIXME: LLVM IR Should allow alloca with an i64 size!
267 Value *Size = EmitScalarExpr(E->getArg(0));
268 Size = Builder.CreateIntCast(Size, llvm::Type::Int32Ty, false, "tmp");
269 return RValue::get(Builder.CreateAlloca(llvm::Type::Int8Ty, Size,
Nate Begeman67365112008-02-06 00:02:50 +0000270 "tmp"));
Chris Lattnere0c190a2008-06-16 17:15:14 +0000271 }
Eli Friedman18bb39e2008-05-19 23:27:48 +0000272 case Builtin::BI__builtin_memcpy: {
273 Value* MemCpyOps[4] = {
274 EmitScalarExpr(E->getArg(0)),
275 EmitScalarExpr(E->getArg(1)),
276 EmitScalarExpr(E->getArg(2)),
277 llvm::ConstantInt::get(llvm::Type::Int32Ty, 0)
278 };
279 Builder.CreateCall(CGM.getMemCpyFn(), MemCpyOps, MemCpyOps+4);
280 return RValue::get(MemCpyOps[0]);
281 }
Eli Friedman60b01632008-05-20 08:59:34 +0000282 case Builtin::BI__builtin_return_address: {
283 Value *F = CGM.getIntrinsic(Intrinsic::returnaddress, 0, 0);
284 return RValue::get(Builder.CreateCall(F, EmitScalarExpr(E->getArg(0))));
285 }
286 case Builtin::BI__builtin_frame_address: {
287 Value *F = CGM.getIntrinsic(Intrinsic::frameaddress, 0, 0);
288 return RValue::get(Builder.CreateCall(F, EmitScalarExpr(E->getArg(0))));
289 }
Mon P Wangbf020f32008-05-09 22:40:52 +0000290 case Builtin::BI__sync_fetch_and_add:
Mon P Wang444244e2008-06-25 08:21:36 +0000291 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_add, E);
Mon P Wangbf020f32008-05-09 22:40:52 +0000292 case Builtin::BI__sync_fetch_and_sub:
Mon P Wang444244e2008-06-25 08:21:36 +0000293 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_sub, E);
Mon P Wangbf020f32008-05-09 22:40:52 +0000294 case Builtin::BI__sync_fetch_and_min:
295 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_min, E);
296 case Builtin::BI__sync_fetch_and_max:
297 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_max, E);
298 case Builtin::BI__sync_fetch_and_umin:
299 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_umin, E);
300 case Builtin::BI__sync_fetch_and_umax:
301 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_umax, E);
302 case Builtin::BI__sync_fetch_and_and:
303 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_and, E);
304 case Builtin::BI__sync_fetch_and_or:
305 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_or, E);
306 case Builtin::BI__sync_fetch_and_xor:
307 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_xor, E);
308 case Builtin::BI__sync_val_compare_and_swap: {
309 Value *Args[3];
310 Args[0]= EmitScalarExpr(E->getArg(0));
311 Args[1] = EmitScalarExpr(E->getArg(1));
312 Args[2] = EmitScalarExpr(E->getArg(2));
313 const llvm::Type *ResType = ConvertType(E->getType());
Mon P Wang444244e2008-06-25 08:21:36 +0000314 Value *AtomF = CGM.getIntrinsic(Intrinsic::atomic_cmp_swap, &ResType, 1);
Mon P Wangbf020f32008-05-09 22:40:52 +0000315 return RValue::get(Builder.CreateCall(AtomF, &Args[0], &Args[1]+2));
Anders Carlsson40438402007-10-29 02:59:40 +0000316 }
Mon P Wangbf020f32008-05-09 22:40:52 +0000317 case Builtin::BI__sync_lock_test_and_set:
Nate Begeman827a4f92008-05-15 07:38:03 +0000318 return EmitBinaryAtomic(*this, Intrinsic::atomic_swap, E);
319 }
Chris Lattner2a674dc2008-06-30 18:32:54 +0000320
321 // If this is an alias for a libm function (e.g. __builtin_sin) turn it into
322 // that function.
323 if (getContext().BuiltinInfo.isLibFunction(BuiltinID))
324 return EmitCallExpr(CGM.getBuiltinLibFunction(BuiltinID),
325 E->getCallee()->getType(), E->arg_begin(),
326 E->arg_end());
327
328 // See if we have a target specific intrinsic.
329 Intrinsic::ID IntrinsicID;
330 const char *TargetPrefix = Target.getTargetPrefix();
331 const char *BuiltinName = getContext().BuiltinInfo.GetName(BuiltinID);
332#define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
333#include "llvm/Intrinsics.gen"
334#undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
335
336 if (IntrinsicID != Intrinsic::not_intrinsic) {
337 SmallVector<Value*, 16> Args;
338
339 Function *F = CGM.getIntrinsic(IntrinsicID);
340 const llvm::FunctionType *FTy = F->getFunctionType();
341
342 for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
343 Value *ArgValue = EmitScalarExpr(E->getArg(i));
344
345 // If the intrinsic arg type is different from the builtin arg type
346 // we need to do a bit cast.
347 const llvm::Type *PTy = FTy->getParamType(i);
348 if (PTy != ArgValue->getType()) {
349 assert(PTy->canLosslesslyBitCastTo(FTy->getParamType(i)) &&
350 "Must be able to losslessly bit cast to param");
351 ArgValue = Builder.CreateBitCast(ArgValue, PTy);
352 }
353
354 Args.push_back(ArgValue);
355 }
356
357 Value *V = Builder.CreateCall(F, &Args[0], &Args[0] + Args.size());
358 QualType BuiltinRetType = E->getType();
359
360 const llvm::Type *RetTy = llvm::Type::VoidTy;
361 if (!BuiltinRetType->isVoidType()) RetTy = ConvertType(BuiltinRetType);
362
363 if (RetTy != V->getType()) {
364 assert(V->getType()->canLosslesslyBitCastTo(RetTy) &&
365 "Must be able to losslessly bit cast result type");
366 V = Builder.CreateBitCast(V, RetTy);
367 }
368
369 return RValue::get(V);
370 }
371
372 // See if we have a target specific builtin that needs to be lowered.
373 Value *V = 0;
374
375 if (strcmp(TargetPrefix, "x86") == 0)
376 V = EmitX86BuiltinExpr(BuiltinID, E);
377 else if (strcmp(TargetPrefix, "ppc") == 0)
378 V = EmitPPCBuiltinExpr(BuiltinID, E);
379
380 if (V)
381 return RValue::get(V);
382
383 WarnUnsupported(E, "builtin function");
384
385 // Unknown builtin, for now just dump it out and return undef.
386 if (hasAggregateLLVMType(E->getType()))
387 return RValue::getAggregate(CreateTempAlloca(ConvertType(E->getType())));
388 return RValue::get(UndefValue::get(ConvertType(E->getType())));
389}
Anders Carlssone1449c12007-12-09 23:17:02 +0000390
Chris Lattner9d37e132007-12-13 07:34:23 +0000391Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
392 const CallExpr *E) {
Anders Carlsson04c4b752007-12-14 17:48:24 +0000393
394 llvm::SmallVector<Value*, 4> Ops;
395
396 for (unsigned i = 0, e = E->getNumArgs(); i != e; i++)
397 Ops.push_back(EmitScalarExpr(E->getArg(i)));
398
Anders Carlssone1449c12007-12-09 23:17:02 +0000399 switch (BuiltinID) {
Anders Carlsson0a35a812007-12-09 23:39:18 +0000400 default: return 0;
401 case X86::BI__builtin_ia32_mulps:
Anders Carlsson04c4b752007-12-14 17:48:24 +0000402 return Builder.CreateMul(Ops[0], Ops[1], "mulps");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000403 case X86::BI__builtin_ia32_mulpd:
404 return Builder.CreateMul(Ops[0], Ops[1], "mulpd");
Anders Carlsson17b80c12007-12-11 02:25:54 +0000405 case X86::BI__builtin_ia32_pand:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000406 case X86::BI__builtin_ia32_pand128:
Anders Carlsson04c4b752007-12-14 17:48:24 +0000407 return Builder.CreateAnd(Ops[0], Ops[1], "pand");
Anders Carlsson17b80c12007-12-11 02:25:54 +0000408 case X86::BI__builtin_ia32_por:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000409 case X86::BI__builtin_ia32_por128:
410 return Builder.CreateOr(Ops[0], Ops[1], "por");
Anders Carlsson17b80c12007-12-11 02:25:54 +0000411 case X86::BI__builtin_ia32_pxor:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000412 case X86::BI__builtin_ia32_pxor128:
413 return Builder.CreateXor(Ops[0], Ops[1], "pxor");
414 case X86::BI__builtin_ia32_pandn:
415 case X86::BI__builtin_ia32_pandn128:
Anders Carlsson04c4b752007-12-14 17:48:24 +0000416 Ops[0] = Builder.CreateNot(Ops[0], "tmp");
417 return Builder.CreateAnd(Ops[0], Ops[1], "pandn");
Anders Carlsson17b80c12007-12-11 02:25:54 +0000418 case X86::BI__builtin_ia32_paddb:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000419 case X86::BI__builtin_ia32_paddb128:
Anders Carlsson17b80c12007-12-11 02:25:54 +0000420 case X86::BI__builtin_ia32_paddd:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000421 case X86::BI__builtin_ia32_paddd128:
Anders Carlsson17b80c12007-12-11 02:25:54 +0000422 case X86::BI__builtin_ia32_paddq:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000423 case X86::BI__builtin_ia32_paddq128:
Anders Carlsson17b80c12007-12-11 02:25:54 +0000424 case X86::BI__builtin_ia32_paddw:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000425 case X86::BI__builtin_ia32_paddw128:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000426 case X86::BI__builtin_ia32_addps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000427 case X86::BI__builtin_ia32_addpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000428 return Builder.CreateAdd(Ops[0], Ops[1], "add");
Anders Carlsson17b80c12007-12-11 02:25:54 +0000429 case X86::BI__builtin_ia32_psubb:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000430 case X86::BI__builtin_ia32_psubb128:
Anders Carlsson17b80c12007-12-11 02:25:54 +0000431 case X86::BI__builtin_ia32_psubd:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000432 case X86::BI__builtin_ia32_psubd128:
Anders Carlsson17b80c12007-12-11 02:25:54 +0000433 case X86::BI__builtin_ia32_psubq:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000434 case X86::BI__builtin_ia32_psubq128:
Anders Carlsson17b80c12007-12-11 02:25:54 +0000435 case X86::BI__builtin_ia32_psubw:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000436 case X86::BI__builtin_ia32_psubw128:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000437 case X86::BI__builtin_ia32_subps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000438 case X86::BI__builtin_ia32_subpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000439 return Builder.CreateSub(Ops[0], Ops[1], "sub");
440 case X86::BI__builtin_ia32_divps:
441 return Builder.CreateFDiv(Ops[0], Ops[1], "divps");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000442 case X86::BI__builtin_ia32_divpd:
443 return Builder.CreateFDiv(Ops[0], Ops[1], "divpd");
Anders Carlsson820cb742007-12-11 03:09:22 +0000444 case X86::BI__builtin_ia32_pmullw:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000445 case X86::BI__builtin_ia32_pmullw128:
Anders Carlsson04c4b752007-12-14 17:48:24 +0000446 return Builder.CreateMul(Ops[0], Ops[1], "pmul");
Anders Carlsson820cb742007-12-11 03:09:22 +0000447 case X86::BI__builtin_ia32_punpckhbw:
Chris Lattner4b23f942007-12-18 00:25:38 +0000448 return EmitShuffleVector(Ops[0], Ops[1], 4, 12, 5, 13, 6, 14, 7, 15,
Anders Carlsson820cb742007-12-11 03:09:22 +0000449 "punpckhbw");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000450 case X86::BI__builtin_ia32_punpckhbw128:
451 return EmitShuffleVector(Ops[0], Ops[1], 8, 24, 9, 25, 10, 26, 11, 27,
452 12, 28, 13, 29, 14, 30, 15, 31,
453 "punpckhbw");
Anders Carlsson820cb742007-12-11 03:09:22 +0000454 case X86::BI__builtin_ia32_punpckhwd:
Chris Lattner4b23f942007-12-18 00:25:38 +0000455 return EmitShuffleVector(Ops[0], Ops[1], 2, 6, 3, 7, "punpckhwd");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000456 case X86::BI__builtin_ia32_punpckhwd128:
457 return EmitShuffleVector(Ops[0], Ops[1], 4, 12, 5, 13, 6, 14, 7, 15,
458 "punpckhwd");
Anders Carlsson820cb742007-12-11 03:09:22 +0000459 case X86::BI__builtin_ia32_punpckhdq:
Chris Lattner4b23f942007-12-18 00:25:38 +0000460 return EmitShuffleVector(Ops[0], Ops[1], 1, 3, "punpckhdq");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000461 case X86::BI__builtin_ia32_punpckhdq128:
462 return EmitShuffleVector(Ops[0], Ops[1], 2, 6, 3, 7, "punpckhdq");
Anders Carlsson820cb742007-12-11 03:09:22 +0000463 case X86::BI__builtin_ia32_punpcklbw:
Chris Lattner4b23f942007-12-18 00:25:38 +0000464 return EmitShuffleVector(Ops[0], Ops[1], 0, 8, 1, 9, 2, 10, 3, 11,
Anders Carlsson820cb742007-12-11 03:09:22 +0000465 "punpcklbw");
466 case X86::BI__builtin_ia32_punpcklwd:
Chris Lattner4b23f942007-12-18 00:25:38 +0000467 return EmitShuffleVector(Ops[0], Ops[1], 0, 4, 1, 5, "punpcklwd");
Anders Carlsson820cb742007-12-11 03:09:22 +0000468 case X86::BI__builtin_ia32_punpckldq:
Chris Lattner4b23f942007-12-18 00:25:38 +0000469 return EmitShuffleVector(Ops[0], Ops[1], 0, 2, "punpckldq");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000470 case X86::BI__builtin_ia32_punpckldq128:
471 return EmitShuffleVector(Ops[0], Ops[1], 0, 4, 1, 5, "punpckldq");
472 case X86::BI__builtin_ia32_pslldi128:
473 case X86::BI__builtin_ia32_psllqi128:
474 case X86::BI__builtin_ia32_psllwi128:
475 case X86::BI__builtin_ia32_psradi128:
476 case X86::BI__builtin_ia32_psrawi128:
477 case X86::BI__builtin_ia32_psrldi128:
478 case X86::BI__builtin_ia32_psrlqi128:
479 case X86::BI__builtin_ia32_psrlwi128: {
480 Ops[1] = Builder.CreateZExt(Ops[1], llvm::Type::Int64Ty, "zext");
481 const llvm::Type *Ty = llvm::VectorType::get(llvm::Type::Int64Ty, 2);
482 llvm::Value *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
483 Ops[1] = Builder.CreateInsertElement(llvm::UndefValue::get(Ty),
484 Ops[1], Zero, "insert");
485 Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType(), "bitcast");
486 const char *name = 0;
487 Intrinsic::ID ID = Intrinsic::not_intrinsic;
488
489 switch (BuiltinID) {
490 default: assert(0 && "Unsupported shift intrinsic!");
491 case X86::BI__builtin_ia32_pslldi128:
492 name = "pslldi";
493 ID = Intrinsic::x86_sse2_psll_d;
494 break;
495 case X86::BI__builtin_ia32_psllqi128:
496 name = "psllqi";
497 ID = Intrinsic::x86_sse2_psll_q;
498 break;
499 case X86::BI__builtin_ia32_psllwi128:
500 name = "psllwi";
501 ID = Intrinsic::x86_sse2_psll_w;
502 break;
503 case X86::BI__builtin_ia32_psradi128:
504 name = "psradi";
505 ID = Intrinsic::x86_sse2_psra_d;
506 break;
507 case X86::BI__builtin_ia32_psrawi128:
508 name = "psrawi";
509 ID = Intrinsic::x86_sse2_psra_w;
510 break;
511 case X86::BI__builtin_ia32_psrldi128:
512 name = "psrldi";
513 ID = Intrinsic::x86_sse2_psrl_d;
514 break;
515 case X86::BI__builtin_ia32_psrlqi128:
516 name = "psrlqi";
517 ID = Intrinsic::x86_sse2_psrl_q;
518 break;
519 case X86::BI__builtin_ia32_psrlwi128:
520 name = "psrlwi";
521 ID = Intrinsic::x86_sse2_psrl_w;
522 break;
523 }
524 llvm::Function *F = CGM.getIntrinsic(ID);
525 return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);
526 }
Anders Carlsson04c4b752007-12-14 17:48:24 +0000527 case X86::BI__builtin_ia32_pslldi:
528 case X86::BI__builtin_ia32_psllqi:
529 case X86::BI__builtin_ia32_psllwi:
530 case X86::BI__builtin_ia32_psradi:
531 case X86::BI__builtin_ia32_psrawi:
532 case X86::BI__builtin_ia32_psrldi:
533 case X86::BI__builtin_ia32_psrlqi:
534 case X86::BI__builtin_ia32_psrlwi: {
535 Ops[1] = Builder.CreateZExt(Ops[1], llvm::Type::Int64Ty, "zext");
536 const llvm::Type *Ty = llvm::VectorType::get(llvm::Type::Int64Ty, 1);
537 Ops[1] = Builder.CreateBitCast(Ops[1], Ty, "bitcast");
Anders Carlsson04c4b752007-12-14 17:48:24 +0000538 const char *name = 0;
539 Intrinsic::ID ID = Intrinsic::not_intrinsic;
540
541 switch (BuiltinID) {
542 default: assert(0 && "Unsupported shift intrinsic!");
543 case X86::BI__builtin_ia32_pslldi:
544 name = "pslldi";
545 ID = Intrinsic::x86_mmx_psll_d;
546 break;
547 case X86::BI__builtin_ia32_psllqi:
548 name = "psllqi";
549 ID = Intrinsic::x86_mmx_psll_q;
550 break;
551 case X86::BI__builtin_ia32_psllwi:
552 name = "psllwi";
553 ID = Intrinsic::x86_mmx_psll_w;
554 break;
555 case X86::BI__builtin_ia32_psradi:
556 name = "psradi";
557 ID = Intrinsic::x86_mmx_psra_d;
558 break;
559 case X86::BI__builtin_ia32_psrawi:
560 name = "psrawi";
561 ID = Intrinsic::x86_mmx_psra_w;
562 break;
563 case X86::BI__builtin_ia32_psrldi:
564 name = "psrldi";
565 ID = Intrinsic::x86_mmx_psrl_d;
566 break;
567 case X86::BI__builtin_ia32_psrlqi:
568 name = "psrlqi";
569 ID = Intrinsic::x86_mmx_psrl_q;
570 break;
571 case X86::BI__builtin_ia32_psrlwi:
572 name = "psrlwi";
573 ID = Intrinsic::x86_mmx_psrl_w;
574 break;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000575 case X86::BI__builtin_ia32_pslldi128:
576 name = "pslldi";
577 ID = Intrinsic::x86_sse2_psll_d;
578 break;
579 case X86::BI__builtin_ia32_psllqi128:
580 name = "psllqi";
581 ID = Intrinsic::x86_sse2_psll_q;
582 break;
583 case X86::BI__builtin_ia32_psllwi128:
584 name = "psllwi";
585 ID = Intrinsic::x86_sse2_psll_w;
586 break;
587 case X86::BI__builtin_ia32_psradi128:
588 name = "psradi";
589 ID = Intrinsic::x86_sse2_psra_d;
590 break;
591 case X86::BI__builtin_ia32_psrawi128:
592 name = "psrawi";
593 ID = Intrinsic::x86_sse2_psra_w;
594 break;
595 case X86::BI__builtin_ia32_psrldi128:
596 name = "psrldi";
597 ID = Intrinsic::x86_sse2_psrl_d;
598 break;
599 case X86::BI__builtin_ia32_psrlqi128:
600 name = "psrlqi";
601 ID = Intrinsic::x86_sse2_psrl_q;
602 break;
603 case X86::BI__builtin_ia32_psrlwi128:
604 name = "psrlwi";
605 ID = Intrinsic::x86_sse2_psrl_w;
606 break;
Anders Carlsson04c4b752007-12-14 17:48:24 +0000607 }
Chris Lattner4b23f942007-12-18 00:25:38 +0000608 llvm::Function *F = CGM.getIntrinsic(ID);
Anders Carlsson04c4b752007-12-14 17:48:24 +0000609 return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);
610 }
Nate Begeman827a4f92008-05-15 07:38:03 +0000611 case X86::BI__builtin_ia32_pshuflw: {
612 unsigned i = cast<ConstantInt>(Ops[1])->getZExtValue();
613 return EmitShuffleVector(Ops[0], Ops[0],
614 i & 0x3, (i & 0xc) >> 2,
615 (i & 0x30) >> 4, (i & 0xc0) >> 6, 4, 5, 6, 7,
616 "pshuflw");
617 }
618 case X86::BI__builtin_ia32_pshufhw: {
619 unsigned i = cast<ConstantInt>(Ops[1])->getZExtValue();
620 return EmitShuffleVector(Ops[0], Ops[0], 0, 1, 2, 3,
621 4 + (i & 0x3), 4 + ((i & 0xc) >> 2),
622 4 + ((i & 0x30) >> 4), 4 + ((i & 0xc0) >> 6),
623 "pshufhw");
624 }
Anders Carlsson04c4b752007-12-14 17:48:24 +0000625 case X86::BI__builtin_ia32_pshufd: {
Chris Lattner4b23f942007-12-18 00:25:38 +0000626 unsigned i = cast<ConstantInt>(Ops[1])->getZExtValue();
Anders Carlsson04c4b752007-12-14 17:48:24 +0000627 return EmitShuffleVector(Ops[0], Ops[0],
Anders Carlsson17b80c12007-12-11 02:25:54 +0000628 i & 0x3, (i & 0xc) >> 2,
629 (i & 0x30) >> 4, (i & 0xc0) >> 6,
630 "pshufd");
631 }
Anders Carlsson68b8be92007-12-15 21:23:30 +0000632 case X86::BI__builtin_ia32_vec_init_v4hi:
633 case X86::BI__builtin_ia32_vec_init_v8qi:
634 case X86::BI__builtin_ia32_vec_init_v2si:
635 return EmitVector(&Ops[0], Ops.size());
636 case X86::BI__builtin_ia32_vec_ext_v2si:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000637 case X86::BI__builtin_ia32_vec_ext_v2di:
638 case X86::BI__builtin_ia32_vec_ext_v4sf:
639 case X86::BI__builtin_ia32_vec_ext_v4si:
640 case X86::BI__builtin_ia32_vec_ext_v2df:
Anders Carlsson68b8be92007-12-15 21:23:30 +0000641 return Builder.CreateExtractElement(Ops[0], Ops[1], "result");
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000642 case X86::BI__builtin_ia32_cmpordss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000643 case X86::BI__builtin_ia32_cmpordsd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000644 case X86::BI__builtin_ia32_cmpunordss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000645 case X86::BI__builtin_ia32_cmpunordsd:
646 case X86::BI__builtin_ia32_cmpeqss:
647 case X86::BI__builtin_ia32_cmpeqsd:
648 case X86::BI__builtin_ia32_cmpltss:
649 case X86::BI__builtin_ia32_cmpltsd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000650 case X86::BI__builtin_ia32_cmpless:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000651 case X86::BI__builtin_ia32_cmplesd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000652 case X86::BI__builtin_ia32_cmpneqss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000653 case X86::BI__builtin_ia32_cmpneqsd:
654 case X86::BI__builtin_ia32_cmpnltss:
655 case X86::BI__builtin_ia32_cmpnltsd:
656 case X86::BI__builtin_ia32_cmpnless:
657 case X86::BI__builtin_ia32_cmpnlesd: {
Chris Lattner4b23f942007-12-18 00:25:38 +0000658 unsigned i = 0;
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000659 const char *name = 0;
660 switch (BuiltinID) {
661 default: assert(0 && "Unknown compare builtin!");
662 case X86::BI__builtin_ia32_cmpeqss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000663 case X86::BI__builtin_ia32_cmpeqsd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000664 i = 0;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000665 name = "cmpeq";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000666 break;
667 case X86::BI__builtin_ia32_cmpltss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000668 case X86::BI__builtin_ia32_cmpltsd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000669 i = 1;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000670 name = "cmplt";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000671 break;
672 case X86::BI__builtin_ia32_cmpless:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000673 case X86::BI__builtin_ia32_cmplesd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000674 i = 2;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000675 name = "cmple";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000676 break;
677 case X86::BI__builtin_ia32_cmpunordss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000678 case X86::BI__builtin_ia32_cmpunordsd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000679 i = 3;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000680 name = "cmpunord";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000681 break;
682 case X86::BI__builtin_ia32_cmpneqss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000683 case X86::BI__builtin_ia32_cmpneqsd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000684 i = 4;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000685 name = "cmpneq";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000686 break;
687 case X86::BI__builtin_ia32_cmpnltss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000688 case X86::BI__builtin_ia32_cmpnltsd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000689 i = 5;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000690 name = "cmpntl";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000691 break;
692 case X86::BI__builtin_ia32_cmpnless:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000693 case X86::BI__builtin_ia32_cmpnlesd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000694 i = 6;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000695 name = "cmpnle";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000696 break;
697 case X86::BI__builtin_ia32_cmpordss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000698 case X86::BI__builtin_ia32_cmpordsd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000699 i = 7;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000700 name = "cmpord";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000701 break;
702 }
703
Nate Begemanbccadaf2008-04-14 04:49:57 +0000704 llvm::Function *F;
705 if (cast<llvm::VectorType>(Ops[0]->getType())->getElementType() ==
706 llvm::Type::FloatTy)
707 F = CGM.getIntrinsic(Intrinsic::x86_sse_cmp_ss);
708 else
709 F = CGM.getIntrinsic(Intrinsic::x86_sse2_cmp_sd);
710
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000711 Ops.push_back(llvm::ConstantInt::get(llvm::Type::Int8Ty, i));
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000712 return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);
713 }
Nate Begemanbccadaf2008-04-14 04:49:57 +0000714 case X86::BI__builtin_ia32_ldmxcsr: {
715 llvm::Type *PtrTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
716 Value *One = llvm::ConstantInt::get(llvm::Type::Int32Ty, 1);
717 Value *Tmp = Builder.CreateAlloca(llvm::Type::Int32Ty, One, "tmp");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000718 Builder.CreateStore(Ops[0], Tmp);
719 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_ldmxcsr),
Chris Lattner7db5e942008-05-06 00:56:42 +0000720 Builder.CreateBitCast(Tmp, PtrTy));
Nate Begemanbccadaf2008-04-14 04:49:57 +0000721 }
722 case X86::BI__builtin_ia32_stmxcsr: {
723 llvm::Type *PtrTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
724 Value *One = llvm::ConstantInt::get(llvm::Type::Int32Ty, 1);
725 Value *Tmp = Builder.CreateAlloca(llvm::Type::Int32Ty, One, "tmp");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000726 One = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_stmxcsr),
Chris Lattner7db5e942008-05-06 00:56:42 +0000727 Builder.CreateBitCast(Tmp, PtrTy));
Nate Begemanbccadaf2008-04-14 04:49:57 +0000728 return Builder.CreateLoad(Tmp, "stmxcsr");
729 }
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000730 case X86::BI__builtin_ia32_cmpordps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000731 case X86::BI__builtin_ia32_cmpordpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000732 case X86::BI__builtin_ia32_cmpunordps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000733 case X86::BI__builtin_ia32_cmpunordpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000734 case X86::BI__builtin_ia32_cmpeqps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000735 case X86::BI__builtin_ia32_cmpeqpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000736 case X86::BI__builtin_ia32_cmpltps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000737 case X86::BI__builtin_ia32_cmpltpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000738 case X86::BI__builtin_ia32_cmpleps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000739 case X86::BI__builtin_ia32_cmplepd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000740 case X86::BI__builtin_ia32_cmpneqps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000741 case X86::BI__builtin_ia32_cmpneqpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000742 case X86::BI__builtin_ia32_cmpngtps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000743 case X86::BI__builtin_ia32_cmpngtpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000744 case X86::BI__builtin_ia32_cmpnltps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000745 case X86::BI__builtin_ia32_cmpnltpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000746 case X86::BI__builtin_ia32_cmpgtps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000747 case X86::BI__builtin_ia32_cmpgtpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000748 case X86::BI__builtin_ia32_cmpgeps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000749 case X86::BI__builtin_ia32_cmpgepd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000750 case X86::BI__builtin_ia32_cmpngeps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000751 case X86::BI__builtin_ia32_cmpngepd:
752 case X86::BI__builtin_ia32_cmpnleps:
753 case X86::BI__builtin_ia32_cmpnlepd: {
Chris Lattner4b23f942007-12-18 00:25:38 +0000754 unsigned i = 0;
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000755 const char *name = 0;
756 bool ShouldSwap = false;
757 switch (BuiltinID) {
758 default: assert(0 && "Unknown compare builtin!");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000759 case X86::BI__builtin_ia32_cmpeqps:
760 case X86::BI__builtin_ia32_cmpeqpd: i = 0; name = "cmpeq"; break;
761 case X86::BI__builtin_ia32_cmpltps:
762 case X86::BI__builtin_ia32_cmpltpd: i = 1; name = "cmplt"; break;
763 case X86::BI__builtin_ia32_cmpleps:
764 case X86::BI__builtin_ia32_cmplepd: i = 2; name = "cmple"; break;
765 case X86::BI__builtin_ia32_cmpunordps:
766 case X86::BI__builtin_ia32_cmpunordpd: i = 3; name = "cmpunord"; break;
767 case X86::BI__builtin_ia32_cmpneqps:
768 case X86::BI__builtin_ia32_cmpneqpd: i = 4; name = "cmpneq"; break;
769 case X86::BI__builtin_ia32_cmpnltps:
770 case X86::BI__builtin_ia32_cmpnltpd: i = 5; name = "cmpntl"; break;
771 case X86::BI__builtin_ia32_cmpnleps:
772 case X86::BI__builtin_ia32_cmpnlepd: i = 6; name = "cmpnle"; break;
773 case X86::BI__builtin_ia32_cmpordps:
774 case X86::BI__builtin_ia32_cmpordpd: i = 7; name = "cmpord"; break;
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000775 case X86::BI__builtin_ia32_cmpgtps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000776 case X86::BI__builtin_ia32_cmpgtpd:
Chris Lattner4b23f942007-12-18 00:25:38 +0000777 ShouldSwap = true;
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000778 i = 1;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000779 name = "cmpgt";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000780 break;
781 case X86::BI__builtin_ia32_cmpgeps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000782 case X86::BI__builtin_ia32_cmpgepd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000783 i = 2;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000784 name = "cmpge";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000785 ShouldSwap = true;
786 break;
787 case X86::BI__builtin_ia32_cmpngtps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000788 case X86::BI__builtin_ia32_cmpngtpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000789 i = 5;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000790 name = "cmpngt";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000791 ShouldSwap = true;
792 break;
793 case X86::BI__builtin_ia32_cmpngeps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000794 case X86::BI__builtin_ia32_cmpngepd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000795 i = 6;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000796 name = "cmpnge";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000797 ShouldSwap = true;
798 break;
799 }
800
801 if (ShouldSwap)
802 std::swap(Ops[0], Ops[1]);
Nate Begemanbccadaf2008-04-14 04:49:57 +0000803
804 llvm::Function *F;
805 if (cast<llvm::VectorType>(Ops[0]->getType())->getElementType() ==
806 llvm::Type::FloatTy)
807 F = CGM.getIntrinsic(Intrinsic::x86_sse_cmp_ps);
808 else
809 F = CGM.getIntrinsic(Intrinsic::x86_sse2_cmp_pd);
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000810
811 Ops.push_back(llvm::ConstantInt::get(llvm::Type::Int8Ty, i));
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000812 return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);
813 }
814 case X86::BI__builtin_ia32_movss:
815 return EmitShuffleVector(Ops[0], Ops[1], 4, 1, 2, 3, "movss");
Edwin Török3b846b12008-04-04 06:16:25 +0000816 case X86::BI__builtin_ia32_shufps: {
Chris Lattner4b23f942007-12-18 00:25:38 +0000817 unsigned i = cast<ConstantInt>(Ops[2])->getZExtValue();
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000818 return EmitShuffleVector(Ops[0], Ops[1],
819 i & 0x3, (i & 0xc) >> 2,
820 ((i & 0x30) >> 4) + 4,
Mon P Wang444244e2008-06-25 08:21:36 +0000821 ((i & 0xc0) >> 6) + 4, "shufps");
Edwin Török3b846b12008-04-04 06:16:25 +0000822 }
Mon P Wangeae56132008-07-18 00:14:09 +0000823 case X86::BI__builtin_ia32_shufpd: {
824 unsigned i = cast<ConstantInt>(Ops[2])->getZExtValue();
825 return EmitShuffleVector(Ops[0], Ops[1], i & 1, (i & 2) + 2, "shufpd");
826 }
Nate Begeman0822c192008-04-03 19:58:06 +0000827 case X86::BI__builtin_ia32_punpcklbw128:
828 return EmitShuffleVector(Ops[0], Ops[1], 0, 16, 1, 17, 2, 18, 3, 19,
829 4, 20, 5, 21, 6, 22, 7, 23,
830 "punpcklbw");
831 case X86::BI__builtin_ia32_punpcklwd128:
832 return EmitShuffleVector(Ops[0], Ops[1], 0, 8, 1, 9, 2, 10, 3, 11,
833 "punpcklwd");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000834 case X86::BI__builtin_ia32_movlhps:
835 return EmitShuffleVector(Ops[0], Ops[1], 0, 1, 4, 5, "movlhps");
836 case X86::BI__builtin_ia32_movhlps:
837 return EmitShuffleVector(Ops[0], Ops[1], 6, 7, 2, 3, "movhlps");
838 case X86::BI__builtin_ia32_unpckhps:
839 return EmitShuffleVector(Ops[0], Ops[1], 2, 6, 3, 7, "unpckhps");
840 case X86::BI__builtin_ia32_unpcklps:
841 return EmitShuffleVector(Ops[0], Ops[1], 0, 4, 1, 5, "unpcklps");
842 case X86::BI__builtin_ia32_movqv4si: {
843 llvm::Type *Ty = llvm::VectorType::get(llvm::Type::Int64Ty, 2);
844 return Builder.CreateBitCast(Ops[0], Ty);
845 }
846 case X86::BI__builtin_ia32_loadlps:
847 case X86::BI__builtin_ia32_loadhps: {
848 // FIXME: This should probably be represented as
849 // shuffle (dst, (v4f32 (insert undef, (load i64), 0)), shuf mask hi/lo)
850 const llvm::Type *EltTy = llvm::Type::DoubleTy;
851 const llvm::Type *VecTy = llvm::VectorType::get(EltTy, 2);
852 const llvm::Type *OrigTy = Ops[0]->getType();
853 unsigned Index = BuiltinID == X86::BI__builtin_ia32_loadlps ? 0 : 1;
854 llvm::Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, Index);
855 Ops[1] = Builder.CreateBitCast(Ops[1], llvm::PointerType::getUnqual(EltTy));
856 Ops[1] = Builder.CreateLoad(Ops[1], "tmp");
857 Ops[0] = Builder.CreateBitCast(Ops[0], VecTy, "cast");
858 Ops[0] = Builder.CreateInsertElement(Ops[0], Ops[1], Idx, "loadps");
859 return Builder.CreateBitCast(Ops[0], OrigTy, "loadps");
860 }
861 case X86::BI__builtin_ia32_storehps:
862 case X86::BI__builtin_ia32_storelps: {
863 const llvm::Type *EltTy = llvm::Type::Int64Ty;
864 llvm::Type *PtrTy = llvm::PointerType::getUnqual(EltTy);
865 llvm::Type *VecTy = llvm::VectorType::get(EltTy, 2);
866
867 // cast val v2i64
868 Ops[1] = Builder.CreateBitCast(Ops[1], VecTy, "cast");
869
870 // extract (0, 1)
871 unsigned Index = BuiltinID == X86::BI__builtin_ia32_storelps ? 0 : 1;
872 llvm::Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, Index);
873 Ops[1] = Builder.CreateExtractElement(Ops[1], Idx, "extract");
874
875 // cast pointer to i64 & store
876 Ops[0] = Builder.CreateBitCast(Ops[0], PtrTy);
877 return Builder.CreateStore(Ops[1], Ops[0]);
878 }
879 case X86::BI__builtin_ia32_loadlv4si: {
880 // load i64
881 const llvm::Type *EltTy = llvm::Type::Int64Ty;
882 llvm::Type *PtrTy = llvm::PointerType::getUnqual(EltTy);
883 Ops[0] = Builder.CreateBitCast(Ops[0], PtrTy);
884 Ops[0] = Builder.CreateLoad(Ops[0], "load");
885
886 // scalar to vector: insert i64 into 2 x i64 undef
887 llvm::Type *VecTy = llvm::VectorType::get(EltTy, 2);
888 llvm::Value *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
889 Ops[0] = Builder.CreateInsertElement(llvm::UndefValue::get(VecTy),
890 Ops[0], Zero, "s2v");
891
892 // shuffle into zero vector.
893 std::vector<llvm::Constant *>Elts;
894 Elts.resize(2, llvm::ConstantInt::get(EltTy, 0));
895 llvm::Value *ZV = ConstantVector::get(Elts);
896 Ops[0] = EmitShuffleVector(ZV, Ops[0], 2, 1, "loadl");
897
898 // bitcast to result.
899 return Builder.CreateBitCast(Ops[0],
900 llvm::VectorType::get(llvm::Type::Int32Ty, 4));
901 }
Nate Begeman300ada52008-05-16 18:59:42 +0000902 case X86::BI__builtin_ia32_vec_set_v4hi:
903 case X86::BI__builtin_ia32_vec_set_v8hi:
904 return Builder.CreateInsertElement(Ops[0], Ops[1], Ops[2], "pinsrw");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000905 case X86::BI__builtin_ia32_andps:
906 case X86::BI__builtin_ia32_andpd:
907 case X86::BI__builtin_ia32_andnps:
908 case X86::BI__builtin_ia32_andnpd:
909 case X86::BI__builtin_ia32_orps:
910 case X86::BI__builtin_ia32_orpd:
911 case X86::BI__builtin_ia32_xorpd:
912 case X86::BI__builtin_ia32_xorps: {
913 const llvm::Type *ITy = llvm::VectorType::get(llvm::Type::Int32Ty, 4);
914 const llvm::Type *FTy = Ops[0]->getType();
915 Ops[0] = Builder.CreateBitCast(Ops[0], ITy, "bitcast");
916 Ops[1] = Builder.CreateBitCast(Ops[1], ITy, "bitcast");
917 switch (BuiltinID) {
918 case X86::BI__builtin_ia32_andps:
919 Ops[0] = Builder.CreateAnd(Ops[0], Ops[1], "andps");
920 break;
921 case X86::BI__builtin_ia32_andpd:
922 Ops[0] = Builder.CreateAnd(Ops[0], Ops[1], "andpd");
923 break;
924 case X86::BI__builtin_ia32_andnps:
925 Ops[0] = Builder.CreateNot(Ops[0], "not");
926 Ops[0] = Builder.CreateAnd(Ops[0], Ops[1], "andnps");
927 break;
928 case X86::BI__builtin_ia32_andnpd:
929 Ops[0] = Builder.CreateNot(Ops[0], "not");
930 Ops[0] = Builder.CreateAnd(Ops[0], Ops[1], "andnpd");
931 break;
932 case X86::BI__builtin_ia32_orps:
933 Ops[0] = Builder.CreateOr(Ops[0], Ops[1], "orps");
934 break;
935 case X86::BI__builtin_ia32_orpd:
936 Ops[0] = Builder.CreateOr(Ops[0], Ops[1], "orpd");
937 break;
938 case X86::BI__builtin_ia32_xorps:
939 Ops[0] = Builder.CreateXor(Ops[0], Ops[1], "xorps");
940 break;
941 case X86::BI__builtin_ia32_xorpd:
942 Ops[0] = Builder.CreateXor(Ops[0], Ops[1], "xorpd");
943 break;
944 }
945 return Builder.CreateBitCast(Ops[0], FTy, "bitcast");
946 }
Anders Carlssone1449c12007-12-09 23:17:02 +0000947 }
948}
949
Chris Lattner9d37e132007-12-13 07:34:23 +0000950Value *CodeGenFunction::EmitPPCBuiltinExpr(unsigned BuiltinID,
951 const CallExpr *E) {
Anders Carlssone1449c12007-12-09 23:17:02 +0000952 switch (BuiltinID) {
Anders Carlsson0a35a812007-12-09 23:39:18 +0000953 default: return 0;
Anders Carlssone1449c12007-12-09 23:17:02 +0000954 }
955}