1 //===---- CGBuiltin.cpp - Emit LLVM Code for builtins ---------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This contains code to emit Builtin calls as LLVM code.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CodeGenFunction.h"
15 #include "CodeGenModule.h"
16 #include "clang/Basic/TargetInfo.h"
17 #include "clang/AST/APValue.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/Decl.h"
20 #include "clang/Basic/TargetBuiltins.h"
21 #include "llvm/Intrinsics.h"
22 using namespace clang;
23 using namespace CodeGen;
24 using namespace llvm;
25 
26 /// Utility to insert an atomic instruction based on Instrinsic::ID
27 /// and the expression node.
28 static RValue EmitBinaryAtomic(CodeGenFunction& CGF,
29                                Intrinsic::ID Id, const CallExpr *E) {
30   const llvm::Type *ResType[2];
31   ResType[0] = CGF.ConvertType(E->getType());
32   ResType[1] = CGF.ConvertType(E->getArg(0)->getType());
33   Value *AtomF = CGF.CGM.getIntrinsic(Id, ResType, 2);
34   return RValue::get(CGF.Builder.CreateCall2(AtomF,
35                                              CGF.EmitScalarExpr(E->getArg(0)),
36                                              CGF.EmitScalarExpr(E->getArg(1))));
37 }
38 
39 /// Utility to insert an atomic instruction based Instrinsic::ID and
40 // the expression node, where the return value is the result of the
41 // operation.
42 static RValue EmitBinaryAtomicPost(CodeGenFunction& CGF,
43                                    Intrinsic::ID Id, const CallExpr *E,
44                                    Instruction::BinaryOps Op) {
45   const llvm::Type *ResType[2];
46   ResType[0] = CGF.ConvertType(E->getType());
47   ResType[1] = CGF.ConvertType(E->getArg(0)->getType());
48   Value *AtomF = CGF.CGM.getIntrinsic(Id, ResType, 2);
49   Value *Ptr = CGF.EmitScalarExpr(E->getArg(0));
50   Value *Operand = CGF.EmitScalarExpr(E->getArg(1));
51   Value *Result = CGF.Builder.CreateCall2(AtomF, Ptr, Operand);
52 
53   if (Id == Intrinsic::atomic_load_nand)
54     Result = CGF.Builder.CreateNot(Result);
55 
56 
57   return RValue::get(CGF.Builder.CreateBinOp(Op, Result, Operand));
58 }
59 
60 RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
61                                         unsigned BuiltinID, const CallExpr *E) {
62   // See if we can constant fold this builtin.  If so, don't emit it at all.
63   Expr::EvalResult Result;
64   if (E->Evaluate(Result, CGM.getContext())) {
65     if (Result.Val.isInt())
66       return RValue::get(llvm::ConstantInt::get(VMContext,
67                                                 Result.Val.getInt()));
68     else if (Result.Val.isFloat())
69       return RValue::get(ConstantFP::get(VMContext, Result.Val.getFloat()));
70   }
71 
72   switch (BuiltinID) {
73   default: break;  // Handle intrinsics and libm functions below.
74   case Builtin::BI__builtin___CFStringMakeConstantString:
75     return RValue::get(CGM.EmitConstantExpr(E, E->getType(), 0));
76   case Builtin::BI__builtin_stdarg_start:
77   case Builtin::BI__builtin_va_start:
78   case Builtin::BI__builtin_va_end: {
79     Value *ArgValue = EmitVAListRef(E->getArg(0));
80     const llvm::Type *DestType =
81       llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
82     if (ArgValue->getType() != DestType)
83       ArgValue = Builder.CreateBitCast(ArgValue, DestType,
84                                        ArgValue->getName().data());
85 
86     Intrinsic::ID inst = (BuiltinID == Builtin::BI__builtin_va_end) ?
87       Intrinsic::vaend : Intrinsic::vastart;
88     return RValue::get(Builder.CreateCall(CGM.getIntrinsic(inst), ArgValue));
89   }
90   case Builtin::BI__builtin_va_copy: {
91     Value *DstPtr = EmitVAListRef(E->getArg(0));
92     Value *SrcPtr = EmitVAListRef(E->getArg(1));
93 
94     const llvm::Type *Type =
95       llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
96 
97     DstPtr = Builder.CreateBitCast(DstPtr, Type);
98     SrcPtr = Builder.CreateBitCast(SrcPtr, Type);
99     return RValue::get(Builder.CreateCall2(CGM.getIntrinsic(Intrinsic::vacopy),
100                                            DstPtr, SrcPtr));
101   }
102   case Builtin::BI__builtin_abs: {
103     Value *ArgValue = EmitScalarExpr(E->getArg(0));
104 
105     Value *NegOp = Builder.CreateNeg(ArgValue, "neg");
106     Value *CmpResult =
107     Builder.CreateICmpSGE(ArgValue,
108                           llvm::Constant::getNullValue(ArgValue->getType()),
109                                                             "abscond");
110     Value *Result =
111       Builder.CreateSelect(CmpResult, ArgValue, NegOp, "abs");
112 
113     return RValue::get(Result);
114   }
115   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   }
129   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   }
143   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                                    llvm::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, llvm::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   case Builtin::BI__builtin_expect:
194     // FIXME: pass expect through to LLVM
195     return RValue::get(EmitScalarExpr(E->getArg(0)));
196   case Builtin::BI__builtin_bswap32:
197   case Builtin::BI__builtin_bswap64: {
198     Value *ArgValue = EmitScalarExpr(E->getArg(0));
199     const llvm::Type *ArgType = ArgValue->getType();
200     Value *F = CGM.getIntrinsic(Intrinsic::bswap, &ArgType, 1);
201     return RValue::get(Builder.CreateCall(F, ArgValue, "tmp"));
202   }
203   case Builtin::BI__builtin_object_size: {
204     // FIXME: Implement. For now we just always fail and pretend we
205     // don't know the object size.
206     llvm::APSInt TypeArg = E->getArg(1)->EvaluateAsInt(CGM.getContext());
207     const llvm::Type *ResType = ConvertType(E->getType());
208     //    bool UseSubObject = TypeArg.getZExtValue() & 1;
209     bool UseMinimum = TypeArg.getZExtValue() & 2;
210     return RValue::get(
211       llvm::ConstantInt::get(ResType, UseMinimum ? 0 : -1LL));
212   }
213   case Builtin::BI__builtin_prefetch: {
214     Value *Locality, *RW, *Address = EmitScalarExpr(E->getArg(0));
215     // FIXME: Technically these constants should of type 'int', yes?
216     RW = (E->getNumArgs() > 1) ? EmitScalarExpr(E->getArg(1)) :
217       llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
218     Locality = (E->getNumArgs() > 2) ? EmitScalarExpr(E->getArg(2)) :
219       llvm::ConstantInt::get(llvm::Type::Int32Ty, 3);
220     Value *F = CGM.getIntrinsic(Intrinsic::prefetch, 0, 0);
221     return RValue::get(Builder.CreateCall3(F, Address, RW, Locality));
222   }
223   case Builtin::BI__builtin_trap: {
224     Value *F = CGM.getIntrinsic(Intrinsic::trap, 0, 0);
225     return RValue::get(Builder.CreateCall(F));
226   }
227 
228   case Builtin::BI__builtin_powi:
229   case Builtin::BI__builtin_powif:
230   case Builtin::BI__builtin_powil: {
231     Value *Base = EmitScalarExpr(E->getArg(0));
232     Value *Exponent = EmitScalarExpr(E->getArg(1));
233     const llvm::Type *ArgType = Base->getType();
234     Value *F = CGM.getIntrinsic(Intrinsic::powi, &ArgType, 1);
235     return RValue::get(Builder.CreateCall2(F, Base, Exponent, "tmp"));
236   }
237 
238   case Builtin::BI__builtin_isgreater:
239   case Builtin::BI__builtin_isgreaterequal:
240   case Builtin::BI__builtin_isless:
241   case Builtin::BI__builtin_islessequal:
242   case Builtin::BI__builtin_islessgreater:
243   case Builtin::BI__builtin_isunordered: {
244     // Ordered comparisons: we know the arguments to these are matching scalar
245     // floating point values.
246     Value *LHS = EmitScalarExpr(E->getArg(0));
247     Value *RHS = EmitScalarExpr(E->getArg(1));
248 
249     switch (BuiltinID) {
250     default: assert(0 && "Unknown ordered comparison");
251     case Builtin::BI__builtin_isgreater:
252       LHS = Builder.CreateFCmpOGT(LHS, RHS, "cmp");
253       break;
254     case Builtin::BI__builtin_isgreaterequal:
255       LHS = Builder.CreateFCmpOGE(LHS, RHS, "cmp");
256       break;
257     case Builtin::BI__builtin_isless:
258       LHS = Builder.CreateFCmpOLT(LHS, RHS, "cmp");
259       break;
260     case Builtin::BI__builtin_islessequal:
261       LHS = Builder.CreateFCmpOLE(LHS, RHS, "cmp");
262       break;
263     case Builtin::BI__builtin_islessgreater:
264       LHS = Builder.CreateFCmpONE(LHS, RHS, "cmp");
265       break;
266     case Builtin::BI__builtin_isunordered:
267       LHS = Builder.CreateFCmpUNO(LHS, RHS, "cmp");
268       break;
269     }
270     // ZExt bool to int type.
271     return RValue::get(Builder.CreateZExt(LHS, ConvertType(E->getType()),
272                                           "tmp"));
273   }
274   case Builtin::BIalloca:
275   case Builtin::BI__builtin_alloca: {
276     // FIXME: LLVM IR Should allow alloca with an i64 size!
277     Value *Size = EmitScalarExpr(E->getArg(0));
278     Size = Builder.CreateIntCast(Size, llvm::Type::Int32Ty, false, "tmp");
279     return RValue::get(Builder.CreateAlloca(llvm::Type::Int8Ty, Size, "tmp"));
280   }
281   case Builtin::BI__builtin_bzero: {
282     Value *Address = EmitScalarExpr(E->getArg(0));
283     Builder.CreateCall4(CGM.getMemSetFn(), Address,
284                         llvm::ConstantInt::get(llvm::Type::Int8Ty, 0),
285                         EmitScalarExpr(E->getArg(1)),
286                         llvm::ConstantInt::get(llvm::Type::Int32Ty, 1));
287     return RValue::get(Address);
288   }
289   case Builtin::BI__builtin_memcpy: {
290     Value *Address = EmitScalarExpr(E->getArg(0));
291     Builder.CreateCall4(CGM.getMemCpyFn(), Address,
292                         EmitScalarExpr(E->getArg(1)),
293                         EmitScalarExpr(E->getArg(2)),
294                         llvm::ConstantInt::get(llvm::Type::Int32Ty, 1));
295     return RValue::get(Address);
296   }
297   case Builtin::BI__builtin_memmove: {
298     Value *Address = EmitScalarExpr(E->getArg(0));
299     Builder.CreateCall4(CGM.getMemMoveFn(), Address,
300                         EmitScalarExpr(E->getArg(1)),
301                         EmitScalarExpr(E->getArg(2)),
302                         llvm::ConstantInt::get(llvm::Type::Int32Ty, 1));
303     return RValue::get(Address);
304   }
305   case Builtin::BI__builtin_memset: {
306     Value *Address = EmitScalarExpr(E->getArg(0));
307     Builder.CreateCall4(CGM.getMemSetFn(), Address,
308                         Builder.CreateTrunc(EmitScalarExpr(E->getArg(1)),
309                                             llvm::Type::Int8Ty),
310                         EmitScalarExpr(E->getArg(2)),
311                         llvm::ConstantInt::get(llvm::Type::Int32Ty, 1));
312     return RValue::get(Address);
313   }
314   case Builtin::BI__builtin_return_address: {
315     Value *F = CGM.getIntrinsic(Intrinsic::returnaddress, 0, 0);
316     return RValue::get(Builder.CreateCall(F, EmitScalarExpr(E->getArg(0))));
317   }
318   case Builtin::BI__builtin_frame_address: {
319     Value *F = CGM.getIntrinsic(Intrinsic::frameaddress, 0, 0);
320     return RValue::get(Builder.CreateCall(F, EmitScalarExpr(E->getArg(0))));
321   }
322   case Builtin::BI__builtin_extract_return_addr: {
323     // FIXME: There should be a target hook for this
324     return RValue::get(EmitScalarExpr(E->getArg(0)));
325   }
326   case Builtin::BI__builtin_unwind_init: {
327     Value *F = CGM.getIntrinsic(Intrinsic::eh_unwind_init, 0, 0);
328     return RValue::get(Builder.CreateCall(F));
329   }
330 #if 0
331   // FIXME: Finish/enable when LLVM backend support stabilizes
332   case Builtin::BI__builtin_setjmp: {
333     Value *Buf = EmitScalarExpr(E->getArg(0));
334     // Store the frame pointer to the buffer
335     Value *FrameAddrF = CGM.getIntrinsic(Intrinsic::frameaddress, 0, 0);
336     Value *FrameAddr =
337         Builder.CreateCall(FrameAddrF,
338                            Constant::getNullValue(llvm::Type::Int32Ty));
339     Builder.CreateStore(FrameAddr, Buf);
340     // Call the setjmp intrinsic
341     Value *F = CGM.getIntrinsic(Intrinsic::eh_sjlj_setjmp, 0, 0);
342     const llvm::Type *DestType =
343       llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
344     Buf = Builder.CreateBitCast(Buf, DestType);
345     return RValue::get(Builder.CreateCall(F, Buf));
346   }
347   case Builtin::BI__builtin_longjmp: {
348     Value *F = CGM.getIntrinsic(Intrinsic::eh_sjlj_longjmp, 0, 0);
349     Value *Buf = EmitScalarExpr(E->getArg(0));
350     const llvm::Type *DestType =
351       llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
352     Buf = Builder.CreateBitCast(Buf, DestType);
353     return RValue::get(Builder.CreateCall(F, Buf));
354   }
355 #endif
356   case Builtin::BI__sync_fetch_and_add:
357   case Builtin::BI__sync_fetch_and_sub:
358   case Builtin::BI__sync_fetch_and_or:
359   case Builtin::BI__sync_fetch_and_and:
360   case Builtin::BI__sync_fetch_and_xor:
361   case Builtin::BI__sync_add_and_fetch:
362   case Builtin::BI__sync_sub_and_fetch:
363   case Builtin::BI__sync_and_and_fetch:
364   case Builtin::BI__sync_or_and_fetch:
365   case Builtin::BI__sync_xor_and_fetch:
366   case Builtin::BI__sync_val_compare_and_swap:
367   case Builtin::BI__sync_bool_compare_and_swap:
368   case Builtin::BI__sync_lock_test_and_set:
369   case Builtin::BI__sync_lock_release:
370     assert(0 && "Shouldn't make it through sema");
371   case Builtin::BI__sync_fetch_and_add_1:
372   case Builtin::BI__sync_fetch_and_add_2:
373   case Builtin::BI__sync_fetch_and_add_4:
374   case Builtin::BI__sync_fetch_and_add_8:
375   case Builtin::BI__sync_fetch_and_add_16:
376     return EmitBinaryAtomic(*this, Intrinsic::atomic_load_add, E);
377   case Builtin::BI__sync_fetch_and_sub_1:
378   case Builtin::BI__sync_fetch_and_sub_2:
379   case Builtin::BI__sync_fetch_and_sub_4:
380   case Builtin::BI__sync_fetch_and_sub_8:
381   case Builtin::BI__sync_fetch_and_sub_16:
382     return EmitBinaryAtomic(*this, Intrinsic::atomic_load_sub, E);
383   case Builtin::BI__sync_fetch_and_or_1:
384   case Builtin::BI__sync_fetch_and_or_2:
385   case Builtin::BI__sync_fetch_and_or_4:
386   case Builtin::BI__sync_fetch_and_or_8:
387   case Builtin::BI__sync_fetch_and_or_16:
388     return EmitBinaryAtomic(*this, Intrinsic::atomic_load_or, E);
389   case Builtin::BI__sync_fetch_and_and_1:
390   case Builtin::BI__sync_fetch_and_and_2:
391   case Builtin::BI__sync_fetch_and_and_4:
392   case Builtin::BI__sync_fetch_and_and_8:
393   case Builtin::BI__sync_fetch_and_and_16:
394     return EmitBinaryAtomic(*this, Intrinsic::atomic_load_and, E);
395   case Builtin::BI__sync_fetch_and_xor_1:
396   case Builtin::BI__sync_fetch_and_xor_2:
397   case Builtin::BI__sync_fetch_and_xor_4:
398   case Builtin::BI__sync_fetch_and_xor_8:
399   case Builtin::BI__sync_fetch_and_xor_16:
400     return EmitBinaryAtomic(*this, Intrinsic::atomic_load_xor, E);
401   case Builtin::BI__sync_fetch_and_nand_1:
402   case Builtin::BI__sync_fetch_and_nand_2:
403   case Builtin::BI__sync_fetch_and_nand_4:
404   case Builtin::BI__sync_fetch_and_nand_8:
405   case Builtin::BI__sync_fetch_and_nand_16:
406     return EmitBinaryAtomic(*this, Intrinsic::atomic_load_nand, E);
407 
408   // Clang extensions: not overloaded yet.
409   case Builtin::BI__sync_fetch_and_min:
410     return EmitBinaryAtomic(*this, Intrinsic::atomic_load_min, E);
411   case Builtin::BI__sync_fetch_and_max:
412     return EmitBinaryAtomic(*this, Intrinsic::atomic_load_max, E);
413   case Builtin::BI__sync_fetch_and_umin:
414     return EmitBinaryAtomic(*this, Intrinsic::atomic_load_umin, E);
415   case Builtin::BI__sync_fetch_and_umax:
416     return EmitBinaryAtomic(*this, Intrinsic::atomic_load_umax, E);
417 
418   case Builtin::BI__sync_add_and_fetch_1:
419   case Builtin::BI__sync_add_and_fetch_2:
420   case Builtin::BI__sync_add_and_fetch_4:
421   case Builtin::BI__sync_add_and_fetch_8:
422   case Builtin::BI__sync_add_and_fetch_16:
423     return EmitBinaryAtomicPost(*this, Intrinsic::atomic_load_add, E,
424                                 llvm::Instruction::Add);
425   case Builtin::BI__sync_sub_and_fetch_1:
426   case Builtin::BI__sync_sub_and_fetch_2:
427   case Builtin::BI__sync_sub_and_fetch_4:
428   case Builtin::BI__sync_sub_and_fetch_8:
429   case Builtin::BI__sync_sub_and_fetch_16:
430     return EmitBinaryAtomicPost(*this, Intrinsic::atomic_load_sub, E,
431                                 llvm::Instruction::Sub);
432   case Builtin::BI__sync_and_and_fetch_1:
433   case Builtin::BI__sync_and_and_fetch_2:
434   case Builtin::BI__sync_and_and_fetch_4:
435   case Builtin::BI__sync_and_and_fetch_8:
436   case Builtin::BI__sync_and_and_fetch_16:
437     return EmitBinaryAtomicPost(*this, Intrinsic::atomic_load_and, E,
438                                 llvm::Instruction::And);
439   case Builtin::BI__sync_or_and_fetch_1:
440   case Builtin::BI__sync_or_and_fetch_2:
441   case Builtin::BI__sync_or_and_fetch_4:
442   case Builtin::BI__sync_or_and_fetch_8:
443   case Builtin::BI__sync_or_and_fetch_16:
444     return EmitBinaryAtomicPost(*this, Intrinsic::atomic_load_or, E,
445                                 llvm::Instruction::Or);
446   case Builtin::BI__sync_xor_and_fetch_1:
447   case Builtin::BI__sync_xor_and_fetch_2:
448   case Builtin::BI__sync_xor_and_fetch_4:
449   case Builtin::BI__sync_xor_and_fetch_8:
450   case Builtin::BI__sync_xor_and_fetch_16:
451     return EmitBinaryAtomicPost(*this, Intrinsic::atomic_load_xor, E,
452                                 llvm::Instruction::Xor);
453   case Builtin::BI__sync_nand_and_fetch_1:
454   case Builtin::BI__sync_nand_and_fetch_2:
455   case Builtin::BI__sync_nand_and_fetch_4:
456   case Builtin::BI__sync_nand_and_fetch_8:
457   case Builtin::BI__sync_nand_and_fetch_16:
458     return EmitBinaryAtomicPost(*this, Intrinsic::atomic_load_nand, E,
459                                 llvm::Instruction::And);
460 
461   case Builtin::BI__sync_val_compare_and_swap_1:
462   case Builtin::BI__sync_val_compare_and_swap_2:
463   case Builtin::BI__sync_val_compare_and_swap_4:
464   case Builtin::BI__sync_val_compare_and_swap_8:
465   case Builtin::BI__sync_val_compare_and_swap_16:
466   {
467     const llvm::Type *ResType[2];
468     ResType[0]= ConvertType(E->getType());
469     ResType[1] = ConvertType(E->getArg(0)->getType());
470     Value *AtomF = CGM.getIntrinsic(Intrinsic::atomic_cmp_swap, ResType, 2);
471     return RValue::get(Builder.CreateCall3(AtomF,
472                                            EmitScalarExpr(E->getArg(0)),
473                                            EmitScalarExpr(E->getArg(1)),
474                                            EmitScalarExpr(E->getArg(2))));
475   }
476 
477   case Builtin::BI__sync_bool_compare_and_swap_1:
478   case Builtin::BI__sync_bool_compare_and_swap_2:
479   case Builtin::BI__sync_bool_compare_and_swap_4:
480   case Builtin::BI__sync_bool_compare_and_swap_8:
481   case Builtin::BI__sync_bool_compare_and_swap_16:
482   {
483     const llvm::Type *ResType[2];
484     ResType[0]= ConvertType(E->getArg(1)->getType());
485     ResType[1] = llvm::PointerType::getUnqual(ResType[0]);
486     Value *AtomF = CGM.getIntrinsic(Intrinsic::atomic_cmp_swap, ResType, 2);
487     Value *OldVal = EmitScalarExpr(E->getArg(1));
488     Value *PrevVal = Builder.CreateCall3(AtomF,
489                                         EmitScalarExpr(E->getArg(0)),
490                                         OldVal,
491                                         EmitScalarExpr(E->getArg(2)));
492     Value *Result = Builder.CreateICmpEQ(PrevVal, OldVal);
493     // zext bool to int.
494     return RValue::get(Builder.CreateZExt(Result, ConvertType(E->getType())));
495   }
496 
497   case Builtin::BI__sync_lock_test_and_set_1:
498   case Builtin::BI__sync_lock_test_and_set_2:
499   case Builtin::BI__sync_lock_test_and_set_4:
500   case Builtin::BI__sync_lock_test_and_set_8:
501   case Builtin::BI__sync_lock_test_and_set_16:
502     return EmitBinaryAtomic(*this, Intrinsic::atomic_swap, E);
503   case Builtin::BI__sync_lock_release_1:
504   case Builtin::BI__sync_lock_release_2:
505   case Builtin::BI__sync_lock_release_4:
506   case Builtin::BI__sync_lock_release_8:
507   case Builtin::BI__sync_lock_release_16: {
508     Value *Ptr = EmitScalarExpr(E->getArg(0));
509     const llvm::Type *ElTy =
510       cast<llvm::PointerType>(Ptr->getType())->getElementType();
511     Builder.CreateStore(llvm::Constant::getNullValue(ElTy), Ptr, true);
512     return RValue::get(0);
513   }
514 
515   case Builtin::BI__sync_synchronize: {
516     Value *C[5];
517     C[0] = C[1] = C[2] = C[3] = llvm::ConstantInt::get(llvm::Type::Int1Ty, 1);
518     C[4] = llvm::ConstantInt::get(llvm::Type::Int1Ty, 0);
519     Builder.CreateCall(CGM.getIntrinsic(Intrinsic::memory_barrier), C, C + 5);
520     return RValue::get(0);
521   }
522 
523     // Library functions with special handling.
524   case Builtin::BIsqrt:
525   case Builtin::BIsqrtf:
526   case Builtin::BIsqrtl: {
527     // Rewrite sqrt to intrinsic if allowed.
528     if (!FD->hasAttr<ConstAttr>())
529       break;
530     Value *Arg0 = EmitScalarExpr(E->getArg(0));
531     const llvm::Type *ArgType = Arg0->getType();
532     Value *F = CGM.getIntrinsic(Intrinsic::sqrt, &ArgType, 1);
533     return RValue::get(Builder.CreateCall(F, Arg0, "tmp"));
534   }
535 
536   case Builtin::BIpow:
537   case Builtin::BIpowf:
538   case Builtin::BIpowl: {
539     // Rewrite sqrt to intrinsic if allowed.
540     if (!FD->hasAttr<ConstAttr>())
541       break;
542     Value *Base = EmitScalarExpr(E->getArg(0));
543     Value *Exponent = EmitScalarExpr(E->getArg(1));
544     const llvm::Type *ArgType = Base->getType();
545     Value *F = CGM.getIntrinsic(Intrinsic::pow, &ArgType, 1);
546     return RValue::get(Builder.CreateCall2(F, Base, Exponent, "tmp"));
547   }
548   }
549 
550   // If this is an alias for a libm function (e.g. __builtin_sin) turn it into
551   // that function.
552   if (getContext().BuiltinInfo.isLibFunction(BuiltinID) ||
553       getContext().BuiltinInfo.isPredefinedLibFunction(BuiltinID))
554     return EmitCall(CGM.getBuiltinLibFunction(BuiltinID),
555                     E->getCallee()->getType(), E->arg_begin(),
556                     E->arg_end());
557 
558   // See if we have a target specific intrinsic.
559   const char *Name = getContext().BuiltinInfo.GetName(BuiltinID);
560   Intrinsic::ID IntrinsicID =
561     Intrinsic::getIntrinsicForGCCBuiltin(Target.getTargetPrefix(), Name);
562 
563   if (IntrinsicID != Intrinsic::not_intrinsic) {
564     SmallVector<Value*, 16> Args;
565 
566     Function *F = CGM.getIntrinsic(IntrinsicID);
567     const llvm::FunctionType *FTy = F->getFunctionType();
568 
569     for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
570       Value *ArgValue = EmitScalarExpr(E->getArg(i));
571 
572       // If the intrinsic arg type is different from the builtin arg type
573       // we need to do a bit cast.
574       const llvm::Type *PTy = FTy->getParamType(i);
575       if (PTy != ArgValue->getType()) {
576         assert(PTy->canLosslesslyBitCastTo(FTy->getParamType(i)) &&
577                "Must be able to losslessly bit cast to param");
578         ArgValue = Builder.CreateBitCast(ArgValue, PTy);
579       }
580 
581       Args.push_back(ArgValue);
582     }
583 
584     Value *V = Builder.CreateCall(F, Args.data(), Args.data() + Args.size());
585     QualType BuiltinRetType = E->getType();
586 
587     const llvm::Type *RetTy = llvm::Type::VoidTy;
588     if (!BuiltinRetType->isVoidType()) RetTy = ConvertType(BuiltinRetType);
589 
590     if (RetTy != V->getType()) {
591       assert(V->getType()->canLosslesslyBitCastTo(RetTy) &&
592              "Must be able to losslessly bit cast result type");
593       V = Builder.CreateBitCast(V, RetTy);
594     }
595 
596     return RValue::get(V);
597   }
598 
599   // See if we have a target specific builtin that needs to be lowered.
600   if (Value *V = EmitTargetBuiltinExpr(BuiltinID, E))
601     return RValue::get(V);
602 
603   ErrorUnsupported(E, "builtin function");
604 
605   // Unknown builtin, for now just dump it out and return undef.
606   if (hasAggregateLLVMType(E->getType()))
607     return RValue::getAggregate(CreateTempAlloca(ConvertType(E->getType())));
608   return RValue::get(llvm::UndefValue::get(ConvertType(E->getType())));
609 }
610 
611 Value *CodeGenFunction::EmitTargetBuiltinExpr(unsigned BuiltinID,
612                                               const CallExpr *E) {
613   const char *TargetPrefix = Target.getTargetPrefix();
614   if (strcmp(TargetPrefix, "x86") == 0)
615     return EmitX86BuiltinExpr(BuiltinID, E);
616   else if (strcmp(TargetPrefix, "ppc") == 0)
617     return EmitPPCBuiltinExpr(BuiltinID, E);
618   return 0;
619 }
620 
621 Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
622                                            const CallExpr *E) {
623 
624   llvm::SmallVector<Value*, 4> Ops;
625 
626   for (unsigned i = 0, e = E->getNumArgs(); i != e; i++)
627     Ops.push_back(EmitScalarExpr(E->getArg(i)));
628 
629   switch (BuiltinID) {
630   default: return 0;
631   case X86::BI__builtin_ia32_pslldi128:
632   case X86::BI__builtin_ia32_psllqi128:
633   case X86::BI__builtin_ia32_psllwi128:
634   case X86::BI__builtin_ia32_psradi128:
635   case X86::BI__builtin_ia32_psrawi128:
636   case X86::BI__builtin_ia32_psrldi128:
637   case X86::BI__builtin_ia32_psrlqi128:
638   case X86::BI__builtin_ia32_psrlwi128: {
639     Ops[1] = Builder.CreateZExt(Ops[1], llvm::Type::Int64Ty, "zext");
640     const llvm::Type *Ty = llvm::VectorType::get(llvm::Type::Int64Ty, 2);
641     llvm::Value *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
642     Ops[1] = Builder.CreateInsertElement(llvm::UndefValue::get(Ty),
643                                          Ops[1], Zero, "insert");
644     Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType(), "bitcast");
645     const char *name = 0;
646     Intrinsic::ID ID = Intrinsic::not_intrinsic;
647 
648     switch (BuiltinID) {
649     default: assert(0 && "Unsupported shift intrinsic!");
650     case X86::BI__builtin_ia32_pslldi128:
651       name = "pslldi";
652       ID = Intrinsic::x86_sse2_psll_d;
653       break;
654     case X86::BI__builtin_ia32_psllqi128:
655       name = "psllqi";
656       ID = Intrinsic::x86_sse2_psll_q;
657       break;
658     case X86::BI__builtin_ia32_psllwi128:
659       name = "psllwi";
660       ID = Intrinsic::x86_sse2_psll_w;
661       break;
662     case X86::BI__builtin_ia32_psradi128:
663       name = "psradi";
664       ID = Intrinsic::x86_sse2_psra_d;
665       break;
666     case X86::BI__builtin_ia32_psrawi128:
667       name = "psrawi";
668       ID = Intrinsic::x86_sse2_psra_w;
669       break;
670     case X86::BI__builtin_ia32_psrldi128:
671       name = "psrldi";
672       ID = Intrinsic::x86_sse2_psrl_d;
673       break;
674     case X86::BI__builtin_ia32_psrlqi128:
675       name = "psrlqi";
676       ID = Intrinsic::x86_sse2_psrl_q;
677       break;
678     case X86::BI__builtin_ia32_psrlwi128:
679       name = "psrlwi";
680       ID = Intrinsic::x86_sse2_psrl_w;
681       break;
682     }
683     llvm::Function *F = CGM.getIntrinsic(ID);
684     return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);
685   }
686   case X86::BI__builtin_ia32_pslldi:
687   case X86::BI__builtin_ia32_psllqi:
688   case X86::BI__builtin_ia32_psllwi:
689   case X86::BI__builtin_ia32_psradi:
690   case X86::BI__builtin_ia32_psrawi:
691   case X86::BI__builtin_ia32_psrldi:
692   case X86::BI__builtin_ia32_psrlqi:
693   case X86::BI__builtin_ia32_psrlwi: {
694     Ops[1] = Builder.CreateZExt(Ops[1], llvm::Type::Int64Ty, "zext");
695     const llvm::Type *Ty = llvm::VectorType::get(llvm::Type::Int64Ty, 1);
696     Ops[1] = Builder.CreateBitCast(Ops[1], Ty, "bitcast");
697     const char *name = 0;
698     Intrinsic::ID ID = Intrinsic::not_intrinsic;
699 
700     switch (BuiltinID) {
701     default: assert(0 && "Unsupported shift intrinsic!");
702     case X86::BI__builtin_ia32_pslldi:
703       name = "pslldi";
704       ID = Intrinsic::x86_mmx_psll_d;
705       break;
706     case X86::BI__builtin_ia32_psllqi:
707       name = "psllqi";
708       ID = Intrinsic::x86_mmx_psll_q;
709       break;
710     case X86::BI__builtin_ia32_psllwi:
711       name = "psllwi";
712       ID = Intrinsic::x86_mmx_psll_w;
713       break;
714     case X86::BI__builtin_ia32_psradi:
715       name = "psradi";
716       ID = Intrinsic::x86_mmx_psra_d;
717       break;
718     case X86::BI__builtin_ia32_psrawi:
719       name = "psrawi";
720       ID = Intrinsic::x86_mmx_psra_w;
721       break;
722     case X86::BI__builtin_ia32_psrldi:
723       name = "psrldi";
724       ID = Intrinsic::x86_mmx_psrl_d;
725       break;
726     case X86::BI__builtin_ia32_psrlqi:
727       name = "psrlqi";
728       ID = Intrinsic::x86_mmx_psrl_q;
729       break;
730     case X86::BI__builtin_ia32_psrlwi:
731       name = "psrlwi";
732       ID = Intrinsic::x86_mmx_psrl_w;
733       break;
734     }
735     llvm::Function *F = CGM.getIntrinsic(ID);
736     return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);
737   }
738   case X86::BI__builtin_ia32_cmpps: {
739     llvm::Function *F = CGM.getIntrinsic(Intrinsic::x86_sse_cmp_ps);
740     return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), "cmpps");
741   }
742   case X86::BI__builtin_ia32_cmpss: {
743     llvm::Function *F = CGM.getIntrinsic(Intrinsic::x86_sse_cmp_ss);
744     return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), "cmpss");
745   }
746   case X86::BI__builtin_ia32_ldmxcsr: {
747     llvm::Type *PtrTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
748     Value *One = llvm::ConstantInt::get(llvm::Type::Int32Ty, 1);
749     Value *Tmp = Builder.CreateAlloca(llvm::Type::Int32Ty, One, "tmp");
750     Builder.CreateStore(Ops[0], Tmp);
751     return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_ldmxcsr),
752                               Builder.CreateBitCast(Tmp, PtrTy));
753   }
754   case X86::BI__builtin_ia32_stmxcsr: {
755     llvm::Type *PtrTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
756     Value *One = llvm::ConstantInt::get(llvm::Type::Int32Ty, 1);
757     Value *Tmp = Builder.CreateAlloca(llvm::Type::Int32Ty, One, "tmp");
758     One = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_stmxcsr),
759                              Builder.CreateBitCast(Tmp, PtrTy));
760     return Builder.CreateLoad(Tmp, "stmxcsr");
761   }
762   case X86::BI__builtin_ia32_cmppd: {
763     llvm::Function *F = CGM.getIntrinsic(Intrinsic::x86_sse2_cmp_pd);
764     return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), "cmppd");
765   }
766   case X86::BI__builtin_ia32_cmpsd: {
767     llvm::Function *F = CGM.getIntrinsic(Intrinsic::x86_sse2_cmp_sd);
768     return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), "cmpsd");
769   }
770   case X86::BI__builtin_ia32_storehps:
771   case X86::BI__builtin_ia32_storelps: {
772     const llvm::Type *EltTy = llvm::Type::Int64Ty;
773     llvm::Type *PtrTy = llvm::PointerType::getUnqual(EltTy);
774     llvm::Type *VecTy = llvm::VectorType::get(EltTy, 2);
775 
776     // cast val v2i64
777     Ops[1] = Builder.CreateBitCast(Ops[1], VecTy, "cast");
778 
779     // extract (0, 1)
780     unsigned Index = BuiltinID == X86::BI__builtin_ia32_storelps ? 0 : 1;
781     llvm::Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, Index);
782     Ops[1] = Builder.CreateExtractElement(Ops[1], Idx, "extract");
783 
784     // cast pointer to i64 & store
785     Ops[0] = Builder.CreateBitCast(Ops[0], PtrTy);
786     return Builder.CreateStore(Ops[1], Ops[0]);
787   }
788   }
789 }
790 
791 Value *CodeGenFunction::EmitPPCBuiltinExpr(unsigned BuiltinID,
792                                            const CallExpr *E) {
793   switch (BuiltinID) {
794   default: return 0;
795   }
796 }
797