blob: a6a479a87dc49135b9f286c8db4a5c0197ea8d49 [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 }
60 case Builtin::BI__builtin_va_start:
61 case Builtin::BI__builtin_va_end: {
Chris Lattner9d37e132007-12-13 07:34:23 +000062 Value *ArgValue = EmitScalarExpr(E->getArg(0));
Christopher Lamb4fe5e702007-12-17 01:11:20 +000063 const llvm::Type *DestType =
64 llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
Anders Carlssoncebb8d62007-10-12 23:56:29 +000065 if (ArgValue->getType() != DestType)
66 ArgValue = Builder.CreateBitCast(ArgValue, DestType,
67 ArgValue->getNameStart());
68
Chris Lattner9d37e132007-12-13 07:34:23 +000069 Intrinsic::ID inst = (BuiltinID == Builtin::BI__builtin_va_start) ?
70 Intrinsic::vastart : Intrinsic::vaend;
Chris Lattner4b23f942007-12-18 00:25:38 +000071 return RValue::get(Builder.CreateCall(CGM.getIntrinsic(inst), ArgValue));
Anders Carlssoncebb8d62007-10-12 23:56:29 +000072 }
Anders Carlssond227c112008-02-09 20:26:43 +000073 case Builtin::BI__builtin_va_copy: {
74 // FIXME: This does not yet handle architectures where va_list is a struct.
75 Value *DstPtr = EmitScalarExpr(E->getArg(0));
76 Value *SrcValue = EmitScalarExpr(E->getArg(1));
77
78 Value *SrcPtr = CreateTempAlloca(SrcValue->getType(), "dst_ptr");
79
Anders Carlssond227c112008-02-09 20:26:43 +000080 Builder.CreateStore(SrcValue, SrcPtr, false);
81
82 const llvm::Type *Type =
83 llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
84
85 DstPtr = Builder.CreateBitCast(DstPtr, Type);
86 SrcPtr = Builder.CreateBitCast(SrcPtr, Type);
Chris Lattner7db5e942008-05-06 00:56:42 +000087 return RValue::get(Builder.CreateCall2(CGM.getIntrinsic(Intrinsic::vacopy),
88 DstPtr, SrcPtr));
Anders Carlssond227c112008-02-09 20:26:43 +000089 }
Anders Carlsson40438402007-10-29 02:59:40 +000090 case Builtin::BI__builtin_classify_type: {
Chris Lattner9d37e132007-12-13 07:34:23 +000091 APSInt Result(32);
Anders Carlsson40438402007-10-29 02:59:40 +000092 if (!E->isBuiltinClassifyType(Result))
93 assert(0 && "Expr not __builtin_classify_type!");
Chris Lattner9d37e132007-12-13 07:34:23 +000094 return RValue::get(ConstantInt::get(Result));
Anders Carlsson49865302007-08-20 18:05:56 +000095 }
Anders Carlsson783e1432007-11-01 00:39:26 +000096 case Builtin::BI__builtin_constant_p: {
Chris Lattner9d37e132007-12-13 07:34:23 +000097 APSInt Result(32);
Anders Carlsson783e1432007-11-01 00:39:26 +000098 // FIXME: Analyze the parameter and check if it is a constant.
99 Result = 0;
Chris Lattner9d37e132007-12-13 07:34:23 +0000100 return RValue::get(ConstantInt::get(Result));
Anders Carlsson783e1432007-11-01 00:39:26 +0000101 }
Anders Carlssone79dbe22007-11-20 19:05:17 +0000102 case Builtin::BI__builtin_abs: {
Chris Lattner9d37e132007-12-13 07:34:23 +0000103 Value *ArgValue = EmitScalarExpr(E->getArg(0));
Anders Carlssone79dbe22007-11-20 19:05:17 +0000104
105 llvm::BinaryOperator *NegOp =
106 Builder.CreateNeg(ArgValue, (ArgValue->getName() + "neg").c_str());
Chris Lattner9d37e132007-12-13 07:34:23 +0000107 Value *CmpResult =
Anders Carlssone79dbe22007-11-20 19:05:17 +0000108 Builder.CreateICmpSGE(ArgValue, NegOp->getOperand(0), "abscond");
Chris Lattner9d37e132007-12-13 07:34:23 +0000109 Value *Result =
Anders Carlssone79dbe22007-11-20 19:05:17 +0000110 Builder.CreateSelect(CmpResult, ArgValue, NegOp, "abs");
111
112 return RValue::get(Result);
113 }
Anders Carlssond50452e2008-02-06 07:19:27 +0000114 case Builtin::BI__builtin_ctz:
115 case Builtin::BI__builtin_ctzl:
116 case Builtin::BI__builtin_ctzll: {
117 Value *ArgValue = EmitScalarExpr(E->getArg(0));
118
119 const llvm::Type *ArgType = ArgValue->getType();
120 Value *F = CGM.getIntrinsic(Intrinsic::cttz, &ArgType, 1);
121
122 const llvm::Type *ResultType = ConvertType(E->getType());
123 Value *Result = Builder.CreateCall(F, ArgValue, "tmp");
124 if (Result->getType() != ResultType)
125 Result = Builder.CreateIntCast(Result, ResultType, "cast");
126 return RValue::get(Result);
127 }
Eli Friedmanecd15162008-05-27 15:32:46 +0000128 case Builtin::BI__builtin_clz:
129 case Builtin::BI__builtin_clzl:
130 case Builtin::BI__builtin_clzll: {
131 Value *ArgValue = EmitScalarExpr(E->getArg(0));
132
133 const llvm::Type *ArgType = ArgValue->getType();
134 Value *F = CGM.getIntrinsic(Intrinsic::ctlz, &ArgType, 1);
135
136 const llvm::Type *ResultType = ConvertType(E->getType());
137 Value *Result = Builder.CreateCall(F, ArgValue, "tmp");
138 if (Result->getType() != ResultType)
139 Result = Builder.CreateIntCast(Result, ResultType, "cast");
140 return RValue::get(Result);
141 }
Chris Lattner9d37e132007-12-13 07:34:23 +0000142 case Builtin::BI__builtin_expect:
143 return RValue::get(EmitScalarExpr(E->getArg(0)));
Anders Carlsson56118002007-12-02 21:58:10 +0000144 case Builtin::BI__builtin_bswap32:
145 case Builtin::BI__builtin_bswap64: {
Chris Lattner9d37e132007-12-13 07:34:23 +0000146 Value *ArgValue = EmitScalarExpr(E->getArg(0));
Anders Carlsson56118002007-12-02 21:58:10 +0000147 const llvm::Type *ArgType = ArgValue->getType();
Chris Lattner4b23f942007-12-18 00:25:38 +0000148 Value *F = CGM.getIntrinsic(Intrinsic::bswap, &ArgType, 1);
Chris Lattner9d37e132007-12-13 07:34:23 +0000149 return RValue::get(Builder.CreateCall(F, ArgValue, "tmp"));
Anders Carlsson56118002007-12-02 21:58:10 +0000150 }
Chris Lattner2a674dc2008-06-30 18:32:54 +0000151 case Builtin::BI__builtin_inff:
Anders Carlsson8fc5f602008-02-01 16:06:34 +0000152 case Builtin::BI__builtin_huge_val:
Anders Carlssona8897f02007-12-05 07:22:48 +0000153 case Builtin::BI__builtin_inf:
Anders Carlssona8897f02007-12-05 07:22:48 +0000154 case Builtin::BI__builtin_infl: {
Chris Lattner2a674dc2008-06-30 18:32:54 +0000155 const llvm::fltSemantics &Sem =
156 CGM.getContext().getFloatTypeSemantics(E->getType());
157 return RValue::get(ConstantFP::get(APFloat::getInf(Sem)));
158 }
159 case Builtin::BI__builtin_nanf:
160 case Builtin::BI__builtin_nan:
161 case Builtin::BI__builtin_nanl: {
162 // If this is __builtin_nan("") turn this into a simple nan, otherwise just
163 // call libm nan.
164 if (const StringLiteral *S =
165 dyn_cast<StringLiteral>(E->getArg(0)->IgnoreParenCasts())) {
166 if (!S->isWide() && S->getByteLength() == 0) { // empty string.
167 const llvm::fltSemantics &Sem =
168 CGM.getContext().getFloatTypeSemantics(E->getType());
169 return RValue::get(ConstantFP::get(APFloat::getNaN(Sem)));
170 }
171 }
172 // Otherwise, call libm 'nan'.
173 break;
Anders Carlssona8897f02007-12-05 07:22:48 +0000174 }
Chris Lattnerd1f26b32007-12-20 00:44:32 +0000175 case Builtin::BI__builtin_isgreater:
176 case Builtin::BI__builtin_isgreaterequal:
177 case Builtin::BI__builtin_isless:
178 case Builtin::BI__builtin_islessequal:
179 case Builtin::BI__builtin_islessgreater:
180 case Builtin::BI__builtin_isunordered: {
181 // Ordered comparisons: we know the arguments to these are matching scalar
182 // floating point values.
183 Value *LHS = EmitScalarExpr(E->getArg(0));
184 Value *RHS = EmitScalarExpr(E->getArg(1));
185
186 switch (BuiltinID) {
187 default: assert(0 && "Unknown ordered comparison");
188 case Builtin::BI__builtin_isgreater:
189 LHS = Builder.CreateFCmpOGT(LHS, RHS, "cmp");
190 break;
191 case Builtin::BI__builtin_isgreaterequal:
192 LHS = Builder.CreateFCmpOGE(LHS, RHS, "cmp");
193 break;
194 case Builtin::BI__builtin_isless:
195 LHS = Builder.CreateFCmpOLT(LHS, RHS, "cmp");
196 break;
197 case Builtin::BI__builtin_islessequal:
198 LHS = Builder.CreateFCmpOLE(LHS, RHS, "cmp");
199 break;
200 case Builtin::BI__builtin_islessgreater:
201 LHS = Builder.CreateFCmpONE(LHS, RHS, "cmp");
202 break;
203 case Builtin::BI__builtin_isunordered:
204 LHS = Builder.CreateFCmpUNO(LHS, RHS, "cmp");
205 break;
206 }
207 // ZExt bool to int type.
208 return RValue::get(Builder.CreateZExt(LHS, ConvertType(E->getType()),
209 "tmp"));
210 }
Chris Lattnere0c190a2008-06-16 17:15:14 +0000211 case Builtin::BI__builtin_alloca: {
212 // FIXME: LLVM IR Should allow alloca with an i64 size!
213 Value *Size = EmitScalarExpr(E->getArg(0));
214 Size = Builder.CreateIntCast(Size, llvm::Type::Int32Ty, false, "tmp");
215 return RValue::get(Builder.CreateAlloca(llvm::Type::Int8Ty, Size,
Nate Begeman67365112008-02-06 00:02:50 +0000216 "tmp"));
Chris Lattnere0c190a2008-06-16 17:15:14 +0000217 }
Eli Friedman18bb39e2008-05-19 23:27:48 +0000218 case Builtin::BI__builtin_memcpy: {
219 Value* MemCpyOps[4] = {
220 EmitScalarExpr(E->getArg(0)),
221 EmitScalarExpr(E->getArg(1)),
222 EmitScalarExpr(E->getArg(2)),
223 llvm::ConstantInt::get(llvm::Type::Int32Ty, 0)
224 };
225 Builder.CreateCall(CGM.getMemCpyFn(), MemCpyOps, MemCpyOps+4);
226 return RValue::get(MemCpyOps[0]);
227 }
Eli Friedman60b01632008-05-20 08:59:34 +0000228 case Builtin::BI__builtin_return_address: {
229 Value *F = CGM.getIntrinsic(Intrinsic::returnaddress, 0, 0);
230 return RValue::get(Builder.CreateCall(F, EmitScalarExpr(E->getArg(0))));
231 }
232 case Builtin::BI__builtin_frame_address: {
233 Value *F = CGM.getIntrinsic(Intrinsic::frameaddress, 0, 0);
234 return RValue::get(Builder.CreateCall(F, EmitScalarExpr(E->getArg(0))));
235 }
Mon P Wangbf020f32008-05-09 22:40:52 +0000236 case Builtin::BI__sync_fetch_and_add:
Mon P Wang444244e2008-06-25 08:21:36 +0000237 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_add, E);
Mon P Wangbf020f32008-05-09 22:40:52 +0000238 case Builtin::BI__sync_fetch_and_sub:
Mon P Wang444244e2008-06-25 08:21:36 +0000239 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_sub, E);
Mon P Wangbf020f32008-05-09 22:40:52 +0000240 case Builtin::BI__sync_fetch_and_min:
241 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_min, E);
242 case Builtin::BI__sync_fetch_and_max:
243 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_max, E);
244 case Builtin::BI__sync_fetch_and_umin:
245 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_umin, E);
246 case Builtin::BI__sync_fetch_and_umax:
247 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_umax, E);
248 case Builtin::BI__sync_fetch_and_and:
249 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_and, E);
250 case Builtin::BI__sync_fetch_and_or:
251 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_or, E);
252 case Builtin::BI__sync_fetch_and_xor:
253 return EmitBinaryAtomic(*this, Intrinsic::atomic_load_xor, E);
254 case Builtin::BI__sync_val_compare_and_swap: {
255 Value *Args[3];
256 Args[0]= EmitScalarExpr(E->getArg(0));
257 Args[1] = EmitScalarExpr(E->getArg(1));
258 Args[2] = EmitScalarExpr(E->getArg(2));
259 const llvm::Type *ResType = ConvertType(E->getType());
Mon P Wang444244e2008-06-25 08:21:36 +0000260 Value *AtomF = CGM.getIntrinsic(Intrinsic::atomic_cmp_swap, &ResType, 1);
Mon P Wangbf020f32008-05-09 22:40:52 +0000261 return RValue::get(Builder.CreateCall(AtomF, &Args[0], &Args[1]+2));
Anders Carlsson40438402007-10-29 02:59:40 +0000262 }
Mon P Wangbf020f32008-05-09 22:40:52 +0000263 case Builtin::BI__sync_lock_test_and_set:
Nate Begeman827a4f92008-05-15 07:38:03 +0000264 return EmitBinaryAtomic(*this, Intrinsic::atomic_swap, E);
265 }
Chris Lattner2a674dc2008-06-30 18:32:54 +0000266
267 // If this is an alias for a libm function (e.g. __builtin_sin) turn it into
268 // that function.
269 if (getContext().BuiltinInfo.isLibFunction(BuiltinID))
270 return EmitCallExpr(CGM.getBuiltinLibFunction(BuiltinID),
271 E->getCallee()->getType(), E->arg_begin(),
272 E->arg_end());
273
274 // See if we have a target specific intrinsic.
275 Intrinsic::ID IntrinsicID;
276 const char *TargetPrefix = Target.getTargetPrefix();
277 const char *BuiltinName = getContext().BuiltinInfo.GetName(BuiltinID);
278#define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
279#include "llvm/Intrinsics.gen"
280#undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
281
282 if (IntrinsicID != Intrinsic::not_intrinsic) {
283 SmallVector<Value*, 16> Args;
284
285 Function *F = CGM.getIntrinsic(IntrinsicID);
286 const llvm::FunctionType *FTy = F->getFunctionType();
287
288 for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
289 Value *ArgValue = EmitScalarExpr(E->getArg(i));
290
291 // If the intrinsic arg type is different from the builtin arg type
292 // we need to do a bit cast.
293 const llvm::Type *PTy = FTy->getParamType(i);
294 if (PTy != ArgValue->getType()) {
295 assert(PTy->canLosslesslyBitCastTo(FTy->getParamType(i)) &&
296 "Must be able to losslessly bit cast to param");
297 ArgValue = Builder.CreateBitCast(ArgValue, PTy);
298 }
299
300 Args.push_back(ArgValue);
301 }
302
303 Value *V = Builder.CreateCall(F, &Args[0], &Args[0] + Args.size());
304 QualType BuiltinRetType = E->getType();
305
306 const llvm::Type *RetTy = llvm::Type::VoidTy;
307 if (!BuiltinRetType->isVoidType()) RetTy = ConvertType(BuiltinRetType);
308
309 if (RetTy != V->getType()) {
310 assert(V->getType()->canLosslesslyBitCastTo(RetTy) &&
311 "Must be able to losslessly bit cast result type");
312 V = Builder.CreateBitCast(V, RetTy);
313 }
314
315 return RValue::get(V);
316 }
317
318 // See if we have a target specific builtin that needs to be lowered.
319 Value *V = 0;
320
321 if (strcmp(TargetPrefix, "x86") == 0)
322 V = EmitX86BuiltinExpr(BuiltinID, E);
323 else if (strcmp(TargetPrefix, "ppc") == 0)
324 V = EmitPPCBuiltinExpr(BuiltinID, E);
325
326 if (V)
327 return RValue::get(V);
328
329 WarnUnsupported(E, "builtin function");
330
331 // Unknown builtin, for now just dump it out and return undef.
332 if (hasAggregateLLVMType(E->getType()))
333 return RValue::getAggregate(CreateTempAlloca(ConvertType(E->getType())));
334 return RValue::get(UndefValue::get(ConvertType(E->getType())));
335}
Anders Carlssone1449c12007-12-09 23:17:02 +0000336
Chris Lattner9d37e132007-12-13 07:34:23 +0000337Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
338 const CallExpr *E) {
Anders Carlsson04c4b752007-12-14 17:48:24 +0000339
340 llvm::SmallVector<Value*, 4> Ops;
341
342 for (unsigned i = 0, e = E->getNumArgs(); i != e; i++)
343 Ops.push_back(EmitScalarExpr(E->getArg(i)));
344
Anders Carlssone1449c12007-12-09 23:17:02 +0000345 switch (BuiltinID) {
Anders Carlsson0a35a812007-12-09 23:39:18 +0000346 default: return 0;
347 case X86::BI__builtin_ia32_mulps:
Anders Carlsson04c4b752007-12-14 17:48:24 +0000348 return Builder.CreateMul(Ops[0], Ops[1], "mulps");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000349 case X86::BI__builtin_ia32_mulpd:
350 return Builder.CreateMul(Ops[0], Ops[1], "mulpd");
Anders Carlsson17b80c12007-12-11 02:25:54 +0000351 case X86::BI__builtin_ia32_pand:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000352 case X86::BI__builtin_ia32_pand128:
Anders Carlsson04c4b752007-12-14 17:48:24 +0000353 return Builder.CreateAnd(Ops[0], Ops[1], "pand");
Anders Carlsson17b80c12007-12-11 02:25:54 +0000354 case X86::BI__builtin_ia32_por:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000355 case X86::BI__builtin_ia32_por128:
356 return Builder.CreateOr(Ops[0], Ops[1], "por");
Anders Carlsson17b80c12007-12-11 02:25:54 +0000357 case X86::BI__builtin_ia32_pxor:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000358 case X86::BI__builtin_ia32_pxor128:
359 return Builder.CreateXor(Ops[0], Ops[1], "pxor");
360 case X86::BI__builtin_ia32_pandn:
361 case X86::BI__builtin_ia32_pandn128:
Anders Carlsson04c4b752007-12-14 17:48:24 +0000362 Ops[0] = Builder.CreateNot(Ops[0], "tmp");
363 return Builder.CreateAnd(Ops[0], Ops[1], "pandn");
Anders Carlsson17b80c12007-12-11 02:25:54 +0000364 case X86::BI__builtin_ia32_paddb:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000365 case X86::BI__builtin_ia32_paddb128:
Anders Carlsson17b80c12007-12-11 02:25:54 +0000366 case X86::BI__builtin_ia32_paddd:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000367 case X86::BI__builtin_ia32_paddd128:
Anders Carlsson17b80c12007-12-11 02:25:54 +0000368 case X86::BI__builtin_ia32_paddq:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000369 case X86::BI__builtin_ia32_paddq128:
Anders Carlsson17b80c12007-12-11 02:25:54 +0000370 case X86::BI__builtin_ia32_paddw:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000371 case X86::BI__builtin_ia32_paddw128:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000372 case X86::BI__builtin_ia32_addps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000373 case X86::BI__builtin_ia32_addpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000374 return Builder.CreateAdd(Ops[0], Ops[1], "add");
Anders Carlsson17b80c12007-12-11 02:25:54 +0000375 case X86::BI__builtin_ia32_psubb:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000376 case X86::BI__builtin_ia32_psubb128:
Anders Carlsson17b80c12007-12-11 02:25:54 +0000377 case X86::BI__builtin_ia32_psubd:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000378 case X86::BI__builtin_ia32_psubd128:
Anders Carlsson17b80c12007-12-11 02:25:54 +0000379 case X86::BI__builtin_ia32_psubq:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000380 case X86::BI__builtin_ia32_psubq128:
Anders Carlsson17b80c12007-12-11 02:25:54 +0000381 case X86::BI__builtin_ia32_psubw:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000382 case X86::BI__builtin_ia32_psubw128:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000383 case X86::BI__builtin_ia32_subps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000384 case X86::BI__builtin_ia32_subpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000385 return Builder.CreateSub(Ops[0], Ops[1], "sub");
386 case X86::BI__builtin_ia32_divps:
387 return Builder.CreateFDiv(Ops[0], Ops[1], "divps");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000388 case X86::BI__builtin_ia32_divpd:
389 return Builder.CreateFDiv(Ops[0], Ops[1], "divpd");
Anders Carlsson820cb742007-12-11 03:09:22 +0000390 case X86::BI__builtin_ia32_pmullw:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000391 case X86::BI__builtin_ia32_pmullw128:
Anders Carlsson04c4b752007-12-14 17:48:24 +0000392 return Builder.CreateMul(Ops[0], Ops[1], "pmul");
Anders Carlsson820cb742007-12-11 03:09:22 +0000393 case X86::BI__builtin_ia32_punpckhbw:
Chris Lattner4b23f942007-12-18 00:25:38 +0000394 return EmitShuffleVector(Ops[0], Ops[1], 4, 12, 5, 13, 6, 14, 7, 15,
Anders Carlsson820cb742007-12-11 03:09:22 +0000395 "punpckhbw");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000396 case X86::BI__builtin_ia32_punpckhbw128:
397 return EmitShuffleVector(Ops[0], Ops[1], 8, 24, 9, 25, 10, 26, 11, 27,
398 12, 28, 13, 29, 14, 30, 15, 31,
399 "punpckhbw");
Anders Carlsson820cb742007-12-11 03:09:22 +0000400 case X86::BI__builtin_ia32_punpckhwd:
Chris Lattner4b23f942007-12-18 00:25:38 +0000401 return EmitShuffleVector(Ops[0], Ops[1], 2, 6, 3, 7, "punpckhwd");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000402 case X86::BI__builtin_ia32_punpckhwd128:
403 return EmitShuffleVector(Ops[0], Ops[1], 4, 12, 5, 13, 6, 14, 7, 15,
404 "punpckhwd");
Anders Carlsson820cb742007-12-11 03:09:22 +0000405 case X86::BI__builtin_ia32_punpckhdq:
Chris Lattner4b23f942007-12-18 00:25:38 +0000406 return EmitShuffleVector(Ops[0], Ops[1], 1, 3, "punpckhdq");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000407 case X86::BI__builtin_ia32_punpckhdq128:
408 return EmitShuffleVector(Ops[0], Ops[1], 2, 6, 3, 7, "punpckhdq");
Anders Carlsson820cb742007-12-11 03:09:22 +0000409 case X86::BI__builtin_ia32_punpcklbw:
Chris Lattner4b23f942007-12-18 00:25:38 +0000410 return EmitShuffleVector(Ops[0], Ops[1], 0, 8, 1, 9, 2, 10, 3, 11,
Anders Carlsson820cb742007-12-11 03:09:22 +0000411 "punpcklbw");
412 case X86::BI__builtin_ia32_punpcklwd:
Chris Lattner4b23f942007-12-18 00:25:38 +0000413 return EmitShuffleVector(Ops[0], Ops[1], 0, 4, 1, 5, "punpcklwd");
Anders Carlsson820cb742007-12-11 03:09:22 +0000414 case X86::BI__builtin_ia32_punpckldq:
Chris Lattner4b23f942007-12-18 00:25:38 +0000415 return EmitShuffleVector(Ops[0], Ops[1], 0, 2, "punpckldq");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000416 case X86::BI__builtin_ia32_punpckldq128:
417 return EmitShuffleVector(Ops[0], Ops[1], 0, 4, 1, 5, "punpckldq");
418 case X86::BI__builtin_ia32_pslldi128:
419 case X86::BI__builtin_ia32_psllqi128:
420 case X86::BI__builtin_ia32_psllwi128:
421 case X86::BI__builtin_ia32_psradi128:
422 case X86::BI__builtin_ia32_psrawi128:
423 case X86::BI__builtin_ia32_psrldi128:
424 case X86::BI__builtin_ia32_psrlqi128:
425 case X86::BI__builtin_ia32_psrlwi128: {
426 Ops[1] = Builder.CreateZExt(Ops[1], llvm::Type::Int64Ty, "zext");
427 const llvm::Type *Ty = llvm::VectorType::get(llvm::Type::Int64Ty, 2);
428 llvm::Value *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
429 Ops[1] = Builder.CreateInsertElement(llvm::UndefValue::get(Ty),
430 Ops[1], Zero, "insert");
431 Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType(), "bitcast");
432 const char *name = 0;
433 Intrinsic::ID ID = Intrinsic::not_intrinsic;
434
435 switch (BuiltinID) {
436 default: assert(0 && "Unsupported shift intrinsic!");
437 case X86::BI__builtin_ia32_pslldi128:
438 name = "pslldi";
439 ID = Intrinsic::x86_sse2_psll_d;
440 break;
441 case X86::BI__builtin_ia32_psllqi128:
442 name = "psllqi";
443 ID = Intrinsic::x86_sse2_psll_q;
444 break;
445 case X86::BI__builtin_ia32_psllwi128:
446 name = "psllwi";
447 ID = Intrinsic::x86_sse2_psll_w;
448 break;
449 case X86::BI__builtin_ia32_psradi128:
450 name = "psradi";
451 ID = Intrinsic::x86_sse2_psra_d;
452 break;
453 case X86::BI__builtin_ia32_psrawi128:
454 name = "psrawi";
455 ID = Intrinsic::x86_sse2_psra_w;
456 break;
457 case X86::BI__builtin_ia32_psrldi128:
458 name = "psrldi";
459 ID = Intrinsic::x86_sse2_psrl_d;
460 break;
461 case X86::BI__builtin_ia32_psrlqi128:
462 name = "psrlqi";
463 ID = Intrinsic::x86_sse2_psrl_q;
464 break;
465 case X86::BI__builtin_ia32_psrlwi128:
466 name = "psrlwi";
467 ID = Intrinsic::x86_sse2_psrl_w;
468 break;
469 }
470 llvm::Function *F = CGM.getIntrinsic(ID);
471 return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);
472 }
Anders Carlsson04c4b752007-12-14 17:48:24 +0000473 case X86::BI__builtin_ia32_pslldi:
474 case X86::BI__builtin_ia32_psllqi:
475 case X86::BI__builtin_ia32_psllwi:
476 case X86::BI__builtin_ia32_psradi:
477 case X86::BI__builtin_ia32_psrawi:
478 case X86::BI__builtin_ia32_psrldi:
479 case X86::BI__builtin_ia32_psrlqi:
480 case X86::BI__builtin_ia32_psrlwi: {
481 Ops[1] = Builder.CreateZExt(Ops[1], llvm::Type::Int64Ty, "zext");
482 const llvm::Type *Ty = llvm::VectorType::get(llvm::Type::Int64Ty, 1);
483 Ops[1] = Builder.CreateBitCast(Ops[1], Ty, "bitcast");
Anders Carlsson04c4b752007-12-14 17:48:24 +0000484 const char *name = 0;
485 Intrinsic::ID ID = Intrinsic::not_intrinsic;
486
487 switch (BuiltinID) {
488 default: assert(0 && "Unsupported shift intrinsic!");
489 case X86::BI__builtin_ia32_pslldi:
490 name = "pslldi";
491 ID = Intrinsic::x86_mmx_psll_d;
492 break;
493 case X86::BI__builtin_ia32_psllqi:
494 name = "psllqi";
495 ID = Intrinsic::x86_mmx_psll_q;
496 break;
497 case X86::BI__builtin_ia32_psllwi:
498 name = "psllwi";
499 ID = Intrinsic::x86_mmx_psll_w;
500 break;
501 case X86::BI__builtin_ia32_psradi:
502 name = "psradi";
503 ID = Intrinsic::x86_mmx_psra_d;
504 break;
505 case X86::BI__builtin_ia32_psrawi:
506 name = "psrawi";
507 ID = Intrinsic::x86_mmx_psra_w;
508 break;
509 case X86::BI__builtin_ia32_psrldi:
510 name = "psrldi";
511 ID = Intrinsic::x86_mmx_psrl_d;
512 break;
513 case X86::BI__builtin_ia32_psrlqi:
514 name = "psrlqi";
515 ID = Intrinsic::x86_mmx_psrl_q;
516 break;
517 case X86::BI__builtin_ia32_psrlwi:
518 name = "psrlwi";
519 ID = Intrinsic::x86_mmx_psrl_w;
520 break;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000521 case X86::BI__builtin_ia32_pslldi128:
522 name = "pslldi";
523 ID = Intrinsic::x86_sse2_psll_d;
524 break;
525 case X86::BI__builtin_ia32_psllqi128:
526 name = "psllqi";
527 ID = Intrinsic::x86_sse2_psll_q;
528 break;
529 case X86::BI__builtin_ia32_psllwi128:
530 name = "psllwi";
531 ID = Intrinsic::x86_sse2_psll_w;
532 break;
533 case X86::BI__builtin_ia32_psradi128:
534 name = "psradi";
535 ID = Intrinsic::x86_sse2_psra_d;
536 break;
537 case X86::BI__builtin_ia32_psrawi128:
538 name = "psrawi";
539 ID = Intrinsic::x86_sse2_psra_w;
540 break;
541 case X86::BI__builtin_ia32_psrldi128:
542 name = "psrldi";
543 ID = Intrinsic::x86_sse2_psrl_d;
544 break;
545 case X86::BI__builtin_ia32_psrlqi128:
546 name = "psrlqi";
547 ID = Intrinsic::x86_sse2_psrl_q;
548 break;
549 case X86::BI__builtin_ia32_psrlwi128:
550 name = "psrlwi";
551 ID = Intrinsic::x86_sse2_psrl_w;
552 break;
Anders Carlsson04c4b752007-12-14 17:48:24 +0000553 }
Chris Lattner4b23f942007-12-18 00:25:38 +0000554 llvm::Function *F = CGM.getIntrinsic(ID);
Anders Carlsson04c4b752007-12-14 17:48:24 +0000555 return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);
556 }
Nate Begeman827a4f92008-05-15 07:38:03 +0000557 case X86::BI__builtin_ia32_pshuflw: {
558 unsigned i = cast<ConstantInt>(Ops[1])->getZExtValue();
559 return EmitShuffleVector(Ops[0], Ops[0],
560 i & 0x3, (i & 0xc) >> 2,
561 (i & 0x30) >> 4, (i & 0xc0) >> 6, 4, 5, 6, 7,
562 "pshuflw");
563 }
564 case X86::BI__builtin_ia32_pshufhw: {
565 unsigned i = cast<ConstantInt>(Ops[1])->getZExtValue();
566 return EmitShuffleVector(Ops[0], Ops[0], 0, 1, 2, 3,
567 4 + (i & 0x3), 4 + ((i & 0xc) >> 2),
568 4 + ((i & 0x30) >> 4), 4 + ((i & 0xc0) >> 6),
569 "pshufhw");
570 }
Anders Carlsson04c4b752007-12-14 17:48:24 +0000571 case X86::BI__builtin_ia32_pshufd: {
Chris Lattner4b23f942007-12-18 00:25:38 +0000572 unsigned i = cast<ConstantInt>(Ops[1])->getZExtValue();
Anders Carlsson04c4b752007-12-14 17:48:24 +0000573 return EmitShuffleVector(Ops[0], Ops[0],
Anders Carlsson17b80c12007-12-11 02:25:54 +0000574 i & 0x3, (i & 0xc) >> 2,
575 (i & 0x30) >> 4, (i & 0xc0) >> 6,
576 "pshufd");
577 }
Anders Carlsson68b8be92007-12-15 21:23:30 +0000578 case X86::BI__builtin_ia32_vec_init_v4hi:
579 case X86::BI__builtin_ia32_vec_init_v8qi:
580 case X86::BI__builtin_ia32_vec_init_v2si:
581 return EmitVector(&Ops[0], Ops.size());
582 case X86::BI__builtin_ia32_vec_ext_v2si:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000583 case X86::BI__builtin_ia32_vec_ext_v2di:
584 case X86::BI__builtin_ia32_vec_ext_v4sf:
585 case X86::BI__builtin_ia32_vec_ext_v4si:
586 case X86::BI__builtin_ia32_vec_ext_v2df:
Anders Carlsson68b8be92007-12-15 21:23:30 +0000587 return Builder.CreateExtractElement(Ops[0], Ops[1], "result");
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000588 case X86::BI__builtin_ia32_cmpordss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000589 case X86::BI__builtin_ia32_cmpordsd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000590 case X86::BI__builtin_ia32_cmpunordss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000591 case X86::BI__builtin_ia32_cmpunordsd:
592 case X86::BI__builtin_ia32_cmpeqss:
593 case X86::BI__builtin_ia32_cmpeqsd:
594 case X86::BI__builtin_ia32_cmpltss:
595 case X86::BI__builtin_ia32_cmpltsd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000596 case X86::BI__builtin_ia32_cmpless:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000597 case X86::BI__builtin_ia32_cmplesd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000598 case X86::BI__builtin_ia32_cmpneqss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000599 case X86::BI__builtin_ia32_cmpneqsd:
600 case X86::BI__builtin_ia32_cmpnltss:
601 case X86::BI__builtin_ia32_cmpnltsd:
602 case X86::BI__builtin_ia32_cmpnless:
603 case X86::BI__builtin_ia32_cmpnlesd: {
Chris Lattner4b23f942007-12-18 00:25:38 +0000604 unsigned i = 0;
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000605 const char *name = 0;
606 switch (BuiltinID) {
607 default: assert(0 && "Unknown compare builtin!");
608 case X86::BI__builtin_ia32_cmpeqss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000609 case X86::BI__builtin_ia32_cmpeqsd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000610 i = 0;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000611 name = "cmpeq";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000612 break;
613 case X86::BI__builtin_ia32_cmpltss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000614 case X86::BI__builtin_ia32_cmpltsd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000615 i = 1;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000616 name = "cmplt";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000617 break;
618 case X86::BI__builtin_ia32_cmpless:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000619 case X86::BI__builtin_ia32_cmplesd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000620 i = 2;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000621 name = "cmple";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000622 break;
623 case X86::BI__builtin_ia32_cmpunordss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000624 case X86::BI__builtin_ia32_cmpunordsd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000625 i = 3;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000626 name = "cmpunord";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000627 break;
628 case X86::BI__builtin_ia32_cmpneqss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000629 case X86::BI__builtin_ia32_cmpneqsd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000630 i = 4;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000631 name = "cmpneq";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000632 break;
633 case X86::BI__builtin_ia32_cmpnltss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000634 case X86::BI__builtin_ia32_cmpnltsd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000635 i = 5;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000636 name = "cmpntl";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000637 break;
638 case X86::BI__builtin_ia32_cmpnless:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000639 case X86::BI__builtin_ia32_cmpnlesd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000640 i = 6;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000641 name = "cmpnle";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000642 break;
643 case X86::BI__builtin_ia32_cmpordss:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000644 case X86::BI__builtin_ia32_cmpordsd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000645 i = 7;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000646 name = "cmpord";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000647 break;
648 }
649
Nate Begemanbccadaf2008-04-14 04:49:57 +0000650 llvm::Function *F;
651 if (cast<llvm::VectorType>(Ops[0]->getType())->getElementType() ==
652 llvm::Type::FloatTy)
653 F = CGM.getIntrinsic(Intrinsic::x86_sse_cmp_ss);
654 else
655 F = CGM.getIntrinsic(Intrinsic::x86_sse2_cmp_sd);
656
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000657 Ops.push_back(llvm::ConstantInt::get(llvm::Type::Int8Ty, i));
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000658 return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);
659 }
Nate Begemanbccadaf2008-04-14 04:49:57 +0000660 case X86::BI__builtin_ia32_ldmxcsr: {
661 llvm::Type *PtrTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
662 Value *One = llvm::ConstantInt::get(llvm::Type::Int32Ty, 1);
663 Value *Tmp = Builder.CreateAlloca(llvm::Type::Int32Ty, One, "tmp");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000664 Builder.CreateStore(Ops[0], Tmp);
665 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_ldmxcsr),
Chris Lattner7db5e942008-05-06 00:56:42 +0000666 Builder.CreateBitCast(Tmp, PtrTy));
Nate Begemanbccadaf2008-04-14 04:49:57 +0000667 }
668 case X86::BI__builtin_ia32_stmxcsr: {
669 llvm::Type *PtrTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
670 Value *One = llvm::ConstantInt::get(llvm::Type::Int32Ty, 1);
671 Value *Tmp = Builder.CreateAlloca(llvm::Type::Int32Ty, One, "tmp");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000672 One = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_stmxcsr),
Chris Lattner7db5e942008-05-06 00:56:42 +0000673 Builder.CreateBitCast(Tmp, PtrTy));
Nate Begemanbccadaf2008-04-14 04:49:57 +0000674 return Builder.CreateLoad(Tmp, "stmxcsr");
675 }
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000676 case X86::BI__builtin_ia32_cmpordps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000677 case X86::BI__builtin_ia32_cmpordpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000678 case X86::BI__builtin_ia32_cmpunordps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000679 case X86::BI__builtin_ia32_cmpunordpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000680 case X86::BI__builtin_ia32_cmpeqps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000681 case X86::BI__builtin_ia32_cmpeqpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000682 case X86::BI__builtin_ia32_cmpltps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000683 case X86::BI__builtin_ia32_cmpltpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000684 case X86::BI__builtin_ia32_cmpleps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000685 case X86::BI__builtin_ia32_cmplepd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000686 case X86::BI__builtin_ia32_cmpneqps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000687 case X86::BI__builtin_ia32_cmpneqpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000688 case X86::BI__builtin_ia32_cmpngtps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000689 case X86::BI__builtin_ia32_cmpngtpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000690 case X86::BI__builtin_ia32_cmpnltps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000691 case X86::BI__builtin_ia32_cmpnltpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000692 case X86::BI__builtin_ia32_cmpgtps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000693 case X86::BI__builtin_ia32_cmpgtpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000694 case X86::BI__builtin_ia32_cmpgeps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000695 case X86::BI__builtin_ia32_cmpgepd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000696 case X86::BI__builtin_ia32_cmpngeps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000697 case X86::BI__builtin_ia32_cmpngepd:
698 case X86::BI__builtin_ia32_cmpnleps:
699 case X86::BI__builtin_ia32_cmpnlepd: {
Chris Lattner4b23f942007-12-18 00:25:38 +0000700 unsigned i = 0;
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000701 const char *name = 0;
702 bool ShouldSwap = false;
703 switch (BuiltinID) {
704 default: assert(0 && "Unknown compare builtin!");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000705 case X86::BI__builtin_ia32_cmpeqps:
706 case X86::BI__builtin_ia32_cmpeqpd: i = 0; name = "cmpeq"; break;
707 case X86::BI__builtin_ia32_cmpltps:
708 case X86::BI__builtin_ia32_cmpltpd: i = 1; name = "cmplt"; break;
709 case X86::BI__builtin_ia32_cmpleps:
710 case X86::BI__builtin_ia32_cmplepd: i = 2; name = "cmple"; break;
711 case X86::BI__builtin_ia32_cmpunordps:
712 case X86::BI__builtin_ia32_cmpunordpd: i = 3; name = "cmpunord"; break;
713 case X86::BI__builtin_ia32_cmpneqps:
714 case X86::BI__builtin_ia32_cmpneqpd: i = 4; name = "cmpneq"; break;
715 case X86::BI__builtin_ia32_cmpnltps:
716 case X86::BI__builtin_ia32_cmpnltpd: i = 5; name = "cmpntl"; break;
717 case X86::BI__builtin_ia32_cmpnleps:
718 case X86::BI__builtin_ia32_cmpnlepd: i = 6; name = "cmpnle"; break;
719 case X86::BI__builtin_ia32_cmpordps:
720 case X86::BI__builtin_ia32_cmpordpd: i = 7; name = "cmpord"; break;
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000721 case X86::BI__builtin_ia32_cmpgtps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000722 case X86::BI__builtin_ia32_cmpgtpd:
Chris Lattner4b23f942007-12-18 00:25:38 +0000723 ShouldSwap = true;
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000724 i = 1;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000725 name = "cmpgt";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000726 break;
727 case X86::BI__builtin_ia32_cmpgeps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000728 case X86::BI__builtin_ia32_cmpgepd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000729 i = 2;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000730 name = "cmpge";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000731 ShouldSwap = true;
732 break;
733 case X86::BI__builtin_ia32_cmpngtps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000734 case X86::BI__builtin_ia32_cmpngtpd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000735 i = 5;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000736 name = "cmpngt";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000737 ShouldSwap = true;
738 break;
739 case X86::BI__builtin_ia32_cmpngeps:
Nate Begemanbccadaf2008-04-14 04:49:57 +0000740 case X86::BI__builtin_ia32_cmpngepd:
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000741 i = 6;
Nate Begemanbccadaf2008-04-14 04:49:57 +0000742 name = "cmpnge";
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000743 ShouldSwap = true;
744 break;
745 }
746
747 if (ShouldSwap)
748 std::swap(Ops[0], Ops[1]);
Nate Begemanbccadaf2008-04-14 04:49:57 +0000749
750 llvm::Function *F;
751 if (cast<llvm::VectorType>(Ops[0]->getType())->getElementType() ==
752 llvm::Type::FloatTy)
753 F = CGM.getIntrinsic(Intrinsic::x86_sse_cmp_ps);
754 else
755 F = CGM.getIntrinsic(Intrinsic::x86_sse2_cmp_pd);
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000756
757 Ops.push_back(llvm::ConstantInt::get(llvm::Type::Int8Ty, i));
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000758 return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);
759 }
760 case X86::BI__builtin_ia32_movss:
761 return EmitShuffleVector(Ops[0], Ops[1], 4, 1, 2, 3, "movss");
Edwin Török3b846b12008-04-04 06:16:25 +0000762 case X86::BI__builtin_ia32_shufps: {
Chris Lattner4b23f942007-12-18 00:25:38 +0000763 unsigned i = cast<ConstantInt>(Ops[2])->getZExtValue();
Anders Carlsson1ad775f2007-12-16 22:33:50 +0000764 return EmitShuffleVector(Ops[0], Ops[1],
765 i & 0x3, (i & 0xc) >> 2,
766 ((i & 0x30) >> 4) + 4,
Mon P Wang444244e2008-06-25 08:21:36 +0000767 ((i & 0xc0) >> 6) + 4, "shufps");
Edwin Török3b846b12008-04-04 06:16:25 +0000768 }
Nate Begeman0822c192008-04-03 19:58:06 +0000769 case X86::BI__builtin_ia32_punpcklbw128:
770 return EmitShuffleVector(Ops[0], Ops[1], 0, 16, 1, 17, 2, 18, 3, 19,
771 4, 20, 5, 21, 6, 22, 7, 23,
772 "punpcklbw");
773 case X86::BI__builtin_ia32_punpcklwd128:
774 return EmitShuffleVector(Ops[0], Ops[1], 0, 8, 1, 9, 2, 10, 3, 11,
775 "punpcklwd");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000776 case X86::BI__builtin_ia32_movlhps:
777 return EmitShuffleVector(Ops[0], Ops[1], 0, 1, 4, 5, "movlhps");
778 case X86::BI__builtin_ia32_movhlps:
779 return EmitShuffleVector(Ops[0], Ops[1], 6, 7, 2, 3, "movhlps");
780 case X86::BI__builtin_ia32_unpckhps:
781 return EmitShuffleVector(Ops[0], Ops[1], 2, 6, 3, 7, "unpckhps");
782 case X86::BI__builtin_ia32_unpcklps:
783 return EmitShuffleVector(Ops[0], Ops[1], 0, 4, 1, 5, "unpcklps");
784 case X86::BI__builtin_ia32_movqv4si: {
785 llvm::Type *Ty = llvm::VectorType::get(llvm::Type::Int64Ty, 2);
786 return Builder.CreateBitCast(Ops[0], Ty);
787 }
788 case X86::BI__builtin_ia32_loadlps:
789 case X86::BI__builtin_ia32_loadhps: {
790 // FIXME: This should probably be represented as
791 // shuffle (dst, (v4f32 (insert undef, (load i64), 0)), shuf mask hi/lo)
792 const llvm::Type *EltTy = llvm::Type::DoubleTy;
793 const llvm::Type *VecTy = llvm::VectorType::get(EltTy, 2);
794 const llvm::Type *OrigTy = Ops[0]->getType();
795 unsigned Index = BuiltinID == X86::BI__builtin_ia32_loadlps ? 0 : 1;
796 llvm::Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, Index);
797 Ops[1] = Builder.CreateBitCast(Ops[1], llvm::PointerType::getUnqual(EltTy));
798 Ops[1] = Builder.CreateLoad(Ops[1], "tmp");
799 Ops[0] = Builder.CreateBitCast(Ops[0], VecTy, "cast");
800 Ops[0] = Builder.CreateInsertElement(Ops[0], Ops[1], Idx, "loadps");
801 return Builder.CreateBitCast(Ops[0], OrigTy, "loadps");
802 }
803 case X86::BI__builtin_ia32_storehps:
804 case X86::BI__builtin_ia32_storelps: {
805 const llvm::Type *EltTy = llvm::Type::Int64Ty;
806 llvm::Type *PtrTy = llvm::PointerType::getUnqual(EltTy);
807 llvm::Type *VecTy = llvm::VectorType::get(EltTy, 2);
808
809 // cast val v2i64
810 Ops[1] = Builder.CreateBitCast(Ops[1], VecTy, "cast");
811
812 // extract (0, 1)
813 unsigned Index = BuiltinID == X86::BI__builtin_ia32_storelps ? 0 : 1;
814 llvm::Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, Index);
815 Ops[1] = Builder.CreateExtractElement(Ops[1], Idx, "extract");
816
817 // cast pointer to i64 & store
818 Ops[0] = Builder.CreateBitCast(Ops[0], PtrTy);
819 return Builder.CreateStore(Ops[1], Ops[0]);
820 }
821 case X86::BI__builtin_ia32_loadlv4si: {
822 // load i64
823 const llvm::Type *EltTy = llvm::Type::Int64Ty;
824 llvm::Type *PtrTy = llvm::PointerType::getUnqual(EltTy);
825 Ops[0] = Builder.CreateBitCast(Ops[0], PtrTy);
826 Ops[0] = Builder.CreateLoad(Ops[0], "load");
827
828 // scalar to vector: insert i64 into 2 x i64 undef
829 llvm::Type *VecTy = llvm::VectorType::get(EltTy, 2);
830 llvm::Value *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
831 Ops[0] = Builder.CreateInsertElement(llvm::UndefValue::get(VecTy),
832 Ops[0], Zero, "s2v");
833
834 // shuffle into zero vector.
835 std::vector<llvm::Constant *>Elts;
836 Elts.resize(2, llvm::ConstantInt::get(EltTy, 0));
837 llvm::Value *ZV = ConstantVector::get(Elts);
838 Ops[0] = EmitShuffleVector(ZV, Ops[0], 2, 1, "loadl");
839
840 // bitcast to result.
841 return Builder.CreateBitCast(Ops[0],
842 llvm::VectorType::get(llvm::Type::Int32Ty, 4));
843 }
Nate Begeman300ada52008-05-16 18:59:42 +0000844 case X86::BI__builtin_ia32_vec_set_v4hi:
845 case X86::BI__builtin_ia32_vec_set_v8hi:
846 return Builder.CreateInsertElement(Ops[0], Ops[1], Ops[2], "pinsrw");
Nate Begemanbccadaf2008-04-14 04:49:57 +0000847 case X86::BI__builtin_ia32_andps:
848 case X86::BI__builtin_ia32_andpd:
849 case X86::BI__builtin_ia32_andnps:
850 case X86::BI__builtin_ia32_andnpd:
851 case X86::BI__builtin_ia32_orps:
852 case X86::BI__builtin_ia32_orpd:
853 case X86::BI__builtin_ia32_xorpd:
854 case X86::BI__builtin_ia32_xorps: {
855 const llvm::Type *ITy = llvm::VectorType::get(llvm::Type::Int32Ty, 4);
856 const llvm::Type *FTy = Ops[0]->getType();
857 Ops[0] = Builder.CreateBitCast(Ops[0], ITy, "bitcast");
858 Ops[1] = Builder.CreateBitCast(Ops[1], ITy, "bitcast");
859 switch (BuiltinID) {
860 case X86::BI__builtin_ia32_andps:
861 Ops[0] = Builder.CreateAnd(Ops[0], Ops[1], "andps");
862 break;
863 case X86::BI__builtin_ia32_andpd:
864 Ops[0] = Builder.CreateAnd(Ops[0], Ops[1], "andpd");
865 break;
866 case X86::BI__builtin_ia32_andnps:
867 Ops[0] = Builder.CreateNot(Ops[0], "not");
868 Ops[0] = Builder.CreateAnd(Ops[0], Ops[1], "andnps");
869 break;
870 case X86::BI__builtin_ia32_andnpd:
871 Ops[0] = Builder.CreateNot(Ops[0], "not");
872 Ops[0] = Builder.CreateAnd(Ops[0], Ops[1], "andnpd");
873 break;
874 case X86::BI__builtin_ia32_orps:
875 Ops[0] = Builder.CreateOr(Ops[0], Ops[1], "orps");
876 break;
877 case X86::BI__builtin_ia32_orpd:
878 Ops[0] = Builder.CreateOr(Ops[0], Ops[1], "orpd");
879 break;
880 case X86::BI__builtin_ia32_xorps:
881 Ops[0] = Builder.CreateXor(Ops[0], Ops[1], "xorps");
882 break;
883 case X86::BI__builtin_ia32_xorpd:
884 Ops[0] = Builder.CreateXor(Ops[0], Ops[1], "xorpd");
885 break;
886 }
887 return Builder.CreateBitCast(Ops[0], FTy, "bitcast");
888 }
Anders Carlssone1449c12007-12-09 23:17:02 +0000889 }
890}
891
Chris Lattner9d37e132007-12-13 07:34:23 +0000892Value *CodeGenFunction::EmitPPCBuiltinExpr(unsigned BuiltinID,
893 const CallExpr *E) {
Anders Carlssone1449c12007-12-09 23:17:02 +0000894 switch (BuiltinID) {
Anders Carlsson0a35a812007-12-09 23:39:18 +0000895 default: return 0;
Anders Carlssone1449c12007-12-09 23:17:02 +0000896 }
897}