CGBuiltin.cpp revision dbebb73b86d9fe56c2227bf75c13ea3a49248261 
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/ASTContext.h"
18#include "clang/AST/Builtins.h"
19#include "clang/AST/Expr.h"
20#include "clang/AST/TargetBuiltins.h"
21#include "llvm/Constants.h"
22#include "llvm/Function.h"
23#include "llvm/Intrinsics.h"
24using namespace clang;
25using namespace CodeGen;
26using namespace llvm;
27
28RValue CodeGenFunction::EmitBuiltinExpr(unsigned BuiltinID, const CallExpr *E) {
29  switch (BuiltinID) {
30  default: {
31    if (getContext().BuiltinInfo.isLibFunction(BuiltinID))
32      return EmitCallExpr(CGM.getBuiltinLibFunction(BuiltinID),
33                          E->getCallee()->getType(), E->arg_begin(),
34                          E->getNumArgs());
35
36    // See if we have a target specific intrinsic.
37    Intrinsic::ID IntrinsicID;
38    const char *TargetPrefix = Target.getTargetPrefix();
39    const char *BuiltinName = getContext().BuiltinInfo.GetName(BuiltinID);
40#define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
41#include "llvm/Intrinsics.gen"
42#undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
43
44    if (IntrinsicID != Intrinsic::not_intrinsic) {
45      SmallVector<Value*, 16> Args;
46
47      Function *F = CGM.getIntrinsic(IntrinsicID);
48      const llvm::FunctionType *FTy = F->getFunctionType();
49
50      for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
51        Value *ArgValue = EmitScalarExpr(E->getArg(i));
52
53        // If the intrinsic arg type is different from the builtin arg type
54        // we need to do a bit cast.
55        const llvm::Type *PTy = FTy->getParamType(i);
56        if (PTy != ArgValue->getType()) {
57          assert(PTy->canLosslesslyBitCastTo(FTy->getParamType(i)) &&
58                 "Must be able to losslessly bit cast to param");
59          ArgValue = Builder.CreateBitCast(ArgValue, PTy);
60        }
61
62        Args.push_back(ArgValue);
63      }
64
65      Value *V = Builder.CreateCall(F, &Args[0], &Args[0] + Args.size());
66      QualType BuiltinRetType = E->getType();
67
68      const llvm::Type *RetTy = llvm::Type::VoidTy;
69      if (!BuiltinRetType->isVoidType()) RetTy = ConvertType(BuiltinRetType);
70
71      if (RetTy != V->getType()) {
72        assert(V->getType()->canLosslesslyBitCastTo(RetTy) &&
73               "Must be able to losslessly bit cast result type");
74        V = Builder.CreateBitCast(V, RetTy);
75      }
76
77      return RValue::get(V);
78    }
79
80    // See if we have a target specific builtin that needs to be lowered.
81    Value *V = 0;
82
83    if (strcmp(TargetPrefix, "x86") == 0)
84      V = EmitX86BuiltinExpr(BuiltinID, E);
85    else if (strcmp(TargetPrefix, "ppc") == 0)
86      V = EmitPPCBuiltinExpr(BuiltinID, E);
87
88    if (V)
89      return RValue::get(V);
90
91    WarnUnsupported(E, "builtin function");
92
93    // Unknown builtin, for now just dump it out and return undef.
94    if (hasAggregateLLVMType(E->getType()))
95      return RValue::getAggregate(CreateTempAlloca(ConvertType(E->getType())));
96    return RValue::get(UndefValue::get(ConvertType(E->getType())));
97  }
98  case Builtin::BI__builtin___CFStringMakeConstantString: {
99    const Expr *Arg = E->getArg(0);
100
101    while (1) {
102      if (const ParenExpr *PE = dyn_cast<ParenExpr>(Arg))
103        Arg = PE->getSubExpr();
104      else if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(Arg))
105        Arg = CE->getSubExpr();
106      else
107        break;
108    }
109
110    const StringLiteral *Literal = cast<StringLiteral>(Arg);
111    std::string S(Literal->getStrData(), Literal->getByteLength());
112
113    return RValue::get(CGM.GetAddrOfConstantCFString(S));
114  }
115  case Builtin::BI__builtin_va_start:
116  case Builtin::BI__builtin_va_end: {
117    Value *ArgValue = EmitScalarExpr(E->getArg(0));
118    const llvm::Type *DestType =
119      llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
120    if (ArgValue->getType() != DestType)
121      ArgValue = Builder.CreateBitCast(ArgValue, DestType,
122                                       ArgValue->getNameStart());
123
124    Intrinsic::ID inst = (BuiltinID == Builtin::BI__builtin_va_start) ?
125      Intrinsic::vastart : Intrinsic::vaend;
126    return RValue::get(Builder.CreateCall(CGM.getIntrinsic(inst), ArgValue));
127  }
128  case Builtin::BI__builtin_va_copy: {
129    // FIXME: This does not yet handle architectures where va_list is a struct.
130    Value *DstPtr = EmitScalarExpr(E->getArg(0));
131    Value *SrcValue = EmitScalarExpr(E->getArg(1));
132
133    Value *SrcPtr = CreateTempAlloca(SrcValue->getType(), "dst_ptr");
134
135    // FIXME: Volatile
136    Builder.CreateStore(SrcValue, SrcPtr, false);
137
138    const llvm::Type *Type =
139      llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
140
141    DstPtr = Builder.CreateBitCast(DstPtr, Type);
142    SrcPtr = Builder.CreateBitCast(SrcPtr, Type);
143    Value *Args[] = { DstPtr, SrcPtr };
144    return RValue::get(Builder.CreateCall(CGM.getIntrinsic(Intrinsic::vacopy),
145                                          &Args[0], &Args[2]));
146  }
147  case Builtin::BI__builtin_classify_type: {
148    APSInt Result(32);
149    if (!E->isBuiltinClassifyType(Result))
150      assert(0 && "Expr not __builtin_classify_type!");
151    return RValue::get(ConstantInt::get(Result));
152  }
153  case Builtin::BI__builtin_constant_p: {
154    APSInt Result(32);
155    // FIXME: Analyze the parameter and check if it is a constant.
156    Result = 0;
157    return RValue::get(ConstantInt::get(Result));
158  }
159  case Builtin::BI__builtin_abs: {
160    Value *ArgValue = EmitScalarExpr(E->getArg(0));
161
162    llvm::BinaryOperator *NegOp =
163      Builder.CreateNeg(ArgValue, (ArgValue->getName() + "neg").c_str());
164    Value *CmpResult =
165      Builder.CreateICmpSGE(ArgValue, NegOp->getOperand(0), "abscond");
166    Value *Result =
167      Builder.CreateSelect(CmpResult, ArgValue, NegOp, "abs");
168
169    return RValue::get(Result);
170  }
171  case Builtin::BI__builtin_ctz:
172  case Builtin::BI__builtin_ctzl:
173  case Builtin::BI__builtin_ctzll: {
174    Value *ArgValue = EmitScalarExpr(E->getArg(0));
175
176    const llvm::Type *ArgType = ArgValue->getType();
177    Value *F = CGM.getIntrinsic(Intrinsic::cttz, &ArgType, 1);
178
179    const llvm::Type *ResultType = ConvertType(E->getType());
180    Value *Result = Builder.CreateCall(F, ArgValue, "tmp");
181    if (Result->getType() != ResultType)
182      Result = Builder.CreateIntCast(Result, ResultType, "cast");
183    return RValue::get(Result);
184  }
185  case Builtin::BI__builtin_expect:
186    return RValue::get(EmitScalarExpr(E->getArg(0)));
187  case Builtin::BI__builtin_bswap32:
188  case Builtin::BI__builtin_bswap64: {
189    Value *ArgValue = EmitScalarExpr(E->getArg(0));
190    const llvm::Type *ArgType = ArgValue->getType();
191    Value *F = CGM.getIntrinsic(Intrinsic::bswap, &ArgType, 1);
192    return RValue::get(Builder.CreateCall(F, ArgValue, "tmp"));
193  }
194  case Builtin::BI__builtin_inff: {
195    APFloat f(APFloat::IEEEsingle, APFloat::fcInfinity, false);
196    return RValue::get(ConstantFP::get(llvm::Type::FloatTy, f));
197  }
198  case Builtin::BI__builtin_huge_val:
199  case Builtin::BI__builtin_inf:
200  // FIXME: mapping long double onto double.
201  case Builtin::BI__builtin_infl: {
202    APFloat f(APFloat::IEEEdouble, APFloat::fcInfinity, false);
203    return RValue::get(ConstantFP::get(llvm::Type::DoubleTy, f));
204  }
205  case Builtin::BI__builtin_isgreater:
206  case Builtin::BI__builtin_isgreaterequal:
207  case Builtin::BI__builtin_isless:
208  case Builtin::BI__builtin_islessequal:
209  case Builtin::BI__builtin_islessgreater:
210  case Builtin::BI__builtin_isunordered: {
211    // Ordered comparisons: we know the arguments to these are matching scalar
212    // floating point values.
213    Value *LHS = EmitScalarExpr(E->getArg(0));
214    Value *RHS = EmitScalarExpr(E->getArg(1));
215
216    switch (BuiltinID) {
217    default: assert(0 && "Unknown ordered comparison");
218    case Builtin::BI__builtin_isgreater:
219      LHS = Builder.CreateFCmpOGT(LHS, RHS, "cmp");
220      break;
221    case Builtin::BI__builtin_isgreaterequal:
222      LHS = Builder.CreateFCmpOGE(LHS, RHS, "cmp");
223      break;
224    case Builtin::BI__builtin_isless:
225      LHS = Builder.CreateFCmpOLT(LHS, RHS, "cmp");
226      break;
227    case Builtin::BI__builtin_islessequal:
228      LHS = Builder.CreateFCmpOLE(LHS, RHS, "cmp");
229      break;
230    case Builtin::BI__builtin_islessgreater:
231      LHS = Builder.CreateFCmpONE(LHS, RHS, "cmp");
232      break;
233    case Builtin::BI__builtin_isunordered:
234      LHS = Builder.CreateFCmpUNO(LHS, RHS, "cmp");
235      break;
236    }
237    // ZExt bool to int type.
238    return RValue::get(Builder.CreateZExt(LHS, ConvertType(E->getType()),
239                                          "tmp"));
240  }
241  case Builtin::BI__builtin_alloca:
242    return RValue::get(Builder.CreateAlloca(llvm::Type::Int8Ty,
243                                            EmitScalarExpr(E->getArg(0)),
244                                            "tmp"));
245  }
246  return RValue::get(0);
247}
248
249Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
250                                           const CallExpr *E) {
251
252  llvm::SmallVector<Value*, 4> Ops;
253
254  for (unsigned i = 0, e = E->getNumArgs(); i != e; i++)
255    Ops.push_back(EmitScalarExpr(E->getArg(i)));
256
257  switch (BuiltinID) {
258  default: return 0;
259  case X86::BI__builtin_ia32_mulps:
260    return Builder.CreateMul(Ops[0], Ops[1], "mulps");
261  case X86::BI__builtin_ia32_pand:
262    return Builder.CreateAnd(Ops[0], Ops[1], "pand");
263  case X86::BI__builtin_ia32_por:
264    return Builder.CreateAnd(Ops[0], Ops[1], "por");
265  case X86::BI__builtin_ia32_pxor:
266    return Builder.CreateAnd(Ops[0], Ops[1], "pxor");
267  case X86::BI__builtin_ia32_pandn: {
268    Ops[0] = Builder.CreateNot(Ops[0], "tmp");
269    return Builder.CreateAnd(Ops[0], Ops[1], "pandn");
270  }
271  case X86::BI__builtin_ia32_paddb:
272  case X86::BI__builtin_ia32_paddd:
273  case X86::BI__builtin_ia32_paddq:
274  case X86::BI__builtin_ia32_paddw:
275  case X86::BI__builtin_ia32_addps:
276    return Builder.CreateAdd(Ops[0], Ops[1], "add");
277  case X86::BI__builtin_ia32_psubb:
278  case X86::BI__builtin_ia32_psubd:
279  case X86::BI__builtin_ia32_psubq:
280  case X86::BI__builtin_ia32_psubw:
281  case X86::BI__builtin_ia32_subps:
282    return Builder.CreateSub(Ops[0], Ops[1], "sub");
283  case X86::BI__builtin_ia32_divps:
284    return Builder.CreateFDiv(Ops[0], Ops[1], "divps");
285  case X86::BI__builtin_ia32_pmullw:
286    return Builder.CreateMul(Ops[0], Ops[1], "pmul");
287  case X86::BI__builtin_ia32_punpckhbw:
288    return EmitShuffleVector(Ops[0], Ops[1], 4, 12, 5, 13, 6, 14, 7, 15,
289                             "punpckhbw");
290  case X86::BI__builtin_ia32_punpckhwd:
291    return EmitShuffleVector(Ops[0], Ops[1], 2, 6, 3, 7, "punpckhwd");
292  case X86::BI__builtin_ia32_punpckhdq:
293    return EmitShuffleVector(Ops[0], Ops[1], 1, 3, "punpckhdq");
294  case X86::BI__builtin_ia32_punpcklbw:
295    return EmitShuffleVector(Ops[0], Ops[1], 0, 8, 1, 9, 2, 10, 3, 11,
296                             "punpcklbw");
297  case X86::BI__builtin_ia32_punpcklwd:
298    return EmitShuffleVector(Ops[0], Ops[1], 0, 4, 1, 5, "punpcklwd");
299  case X86::BI__builtin_ia32_punpckldq:
300    return EmitShuffleVector(Ops[0], Ops[1], 0, 2, "punpckldq");
301  case X86::BI__builtin_ia32_pslldi:
302  case X86::BI__builtin_ia32_psllqi:
303  case X86::BI__builtin_ia32_psllwi:
304  case X86::BI__builtin_ia32_psradi:
305  case X86::BI__builtin_ia32_psrawi:
306  case X86::BI__builtin_ia32_psrldi:
307  case X86::BI__builtin_ia32_psrlqi:
308  case X86::BI__builtin_ia32_psrlwi: {
309    Ops[1] = Builder.CreateZExt(Ops[1], llvm::Type::Int64Ty, "zext");
310    const llvm::Type *Ty = llvm::VectorType::get(llvm::Type::Int64Ty, 1);
311    Ops[1] = Builder.CreateBitCast(Ops[1], Ty, "bitcast");
312    const char *name = 0;
313    Intrinsic::ID ID = Intrinsic::not_intrinsic;
314
315    switch (BuiltinID) {
316    default: assert(0 && "Unsupported shift intrinsic!");
317    case X86::BI__builtin_ia32_pslldi:
318      name = "pslldi";
319      ID = Intrinsic::x86_mmx_psll_d;
320      break;
321    case X86::BI__builtin_ia32_psllqi:
322      name = "psllqi";
323      ID = Intrinsic::x86_mmx_psll_q;
324      break;
325    case X86::BI__builtin_ia32_psllwi:
326      name = "psllwi";
327      ID = Intrinsic::x86_mmx_psll_w;
328      break;
329    case X86::BI__builtin_ia32_psradi:
330      name = "psradi";
331      ID = Intrinsic::x86_mmx_psra_d;
332      break;
333    case X86::BI__builtin_ia32_psrawi:
334      name = "psrawi";
335      ID = Intrinsic::x86_mmx_psra_w;
336      break;
337    case X86::BI__builtin_ia32_psrldi:
338      name = "psrldi";
339      ID = Intrinsic::x86_mmx_psrl_d;
340      break;
341    case X86::BI__builtin_ia32_psrlqi:
342      name = "psrlqi";
343      ID = Intrinsic::x86_mmx_psrl_q;
344      break;
345    case X86::BI__builtin_ia32_psrlwi:
346      name = "psrlwi";
347      ID = Intrinsic::x86_mmx_psrl_w;
348      break;
349    }
350    llvm::Function *F = CGM.getIntrinsic(ID);
351    return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);
352  }
353  case X86::BI__builtin_ia32_pshufd: {
354    unsigned i = cast<ConstantInt>(Ops[1])->getZExtValue();
355    return EmitShuffleVector(Ops[0], Ops[0],
356                             i & 0x3, (i & 0xc) >> 2,
357                             (i & 0x30) >> 4, (i & 0xc0) >> 6,
358                             "pshufd");
359  }
360  case X86::BI__builtin_ia32_vec_init_v4hi:
361  case X86::BI__builtin_ia32_vec_init_v8qi:
362  case X86::BI__builtin_ia32_vec_init_v2si:
363    return EmitVector(&Ops[0], Ops.size());
364  case X86::BI__builtin_ia32_vec_ext_v2si:
365    return Builder.CreateExtractElement(Ops[0], Ops[1], "result");
366  case X86::BI__builtin_ia32_cmpordss:
367  case X86::BI__builtin_ia32_cmpunordss:
368  case X86::BI__builtin_ia32_cmpeqss:
369  case X86::BI__builtin_ia32_cmpltss:
370  case X86::BI__builtin_ia32_cmpless:
371  case X86::BI__builtin_ia32_cmpneqss:
372  case X86::BI__builtin_ia32_cmpnltss:
373  case X86::BI__builtin_ia32_cmpnless: {
374    unsigned i = 0;
375    const char *name = 0;
376    switch (BuiltinID) {
377    default: assert(0 && "Unknown compare builtin!");
378    case X86::BI__builtin_ia32_cmpeqss:
379      i = 0;
380      name = "cmpeqss";
381      break;
382    case X86::BI__builtin_ia32_cmpltss:
383      i = 1;
384      name = "cmpltss";
385      break;
386    case X86::BI__builtin_ia32_cmpless:
387      i = 2;
388      name = "cmpless";
389      break;
390    case X86::BI__builtin_ia32_cmpunordss:
391      i = 3;
392      name = "cmpunordss";
393      break;
394    case X86::BI__builtin_ia32_cmpneqss:
395      i = 4;
396      name = "cmpneqss";
397      break;
398    case X86::BI__builtin_ia32_cmpnltss:
399      i = 5;
400      name = "cmpntlss";
401      break;
402    case X86::BI__builtin_ia32_cmpnless:
403      i = 6;
404      name = "cmpnless";
405      break;
406    case X86::BI__builtin_ia32_cmpordss:
407      i = 7;
408      name = "cmpordss";
409      break;
410    }
411
412    Ops.push_back(llvm::ConstantInt::get(llvm::Type::Int8Ty, i));
413    llvm::Function *F = CGM.getIntrinsic(Intrinsic::x86_sse_cmp_ss);
414    return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);
415  }
416  case X86::BI__builtin_ia32_cmpordps:
417  case X86::BI__builtin_ia32_cmpunordps:
418  case X86::BI__builtin_ia32_cmpeqps:
419  case X86::BI__builtin_ia32_cmpltps:
420  case X86::BI__builtin_ia32_cmpleps:
421  case X86::BI__builtin_ia32_cmpneqps:
422  case X86::BI__builtin_ia32_cmpngtps:
423  case X86::BI__builtin_ia32_cmpnltps:
424  case X86::BI__builtin_ia32_cmpgtps:
425  case X86::BI__builtin_ia32_cmpgeps:
426  case X86::BI__builtin_ia32_cmpngeps:
427  case X86::BI__builtin_ia32_cmpnleps: {
428    unsigned i = 0;
429    const char *name = 0;
430    bool ShouldSwap = false;
431    switch (BuiltinID) {
432    default: assert(0 && "Unknown compare builtin!");
433    case X86::BI__builtin_ia32_cmpeqps:    i = 0; name = "cmpeqps"; break;
434    case X86::BI__builtin_ia32_cmpltps:    i = 1; name = "cmpltps"; break;
435    case X86::BI__builtin_ia32_cmpleps:    i = 2; name = "cmpleps"; break;
436    case X86::BI__builtin_ia32_cmpunordps: i = 3; name = "cmpunordps"; break;
437    case X86::BI__builtin_ia32_cmpneqps:   i = 4; name = "cmpneqps"; break;
438    case X86::BI__builtin_ia32_cmpnltps:   i = 5; name = "cmpntlps"; break;
439    case X86::BI__builtin_ia32_cmpnleps:   i = 6; name = "cmpnleps"; break;
440    case X86::BI__builtin_ia32_cmpordps:   i = 7; name = "cmpordps"; break;
441    case X86::BI__builtin_ia32_cmpgtps:
442      ShouldSwap = true;
443      i = 1;
444      name = "cmpgtps";
445      break;
446    case X86::BI__builtin_ia32_cmpgeps:
447      i = 2;
448      name = "cmpgeps";
449      ShouldSwap = true;
450      break;
451    case X86::BI__builtin_ia32_cmpngtps:
452      i = 5;
453      name = "cmpngtps";
454      ShouldSwap = true;
455      break;
456    case X86::BI__builtin_ia32_cmpngeps:
457      i = 6;
458      name = "cmpngeps";
459      ShouldSwap = true;
460      break;
461    }
462
463    if (ShouldSwap)
464      std::swap(Ops[0], Ops[1]);
465
466    Ops.push_back(llvm::ConstantInt::get(llvm::Type::Int8Ty, i));
467    llvm::Function *F = CGM.getIntrinsic(Intrinsic::x86_sse_cmp_ps);
468    return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);
469  }
470  case X86::BI__builtin_ia32_movss:
471    return EmitShuffleVector(Ops[0], Ops[1], 4, 1, 2, 3, "movss");
472  case X86::BI__builtin_ia32_shufps:
473    unsigned i = cast<ConstantInt>(Ops[2])->getZExtValue();
474    return EmitShuffleVector(Ops[0], Ops[1],
475                             i & 0x3, (i & 0xc) >> 2,
476                             ((i & 0x30) >> 4) + 4,
477                             ((i & 0x60) >> 6) + 4, "shufps");
478  case X86::BI__builtin_ia32_punpcklbw128:
479    return EmitShuffleVector(Ops[0], Ops[1], 0, 16, 1, 17, 2, 18, 3, 19,
480                                             4, 20, 5, 21, 6, 22, 7, 23,
481                                             "punpcklbw");
482  case X86::BI__builtin_ia32_punpcklwd128:
483    return EmitShuffleVector(Ops[0], Ops[1], 0, 8, 1, 9, 2, 10, 3, 11,
484                             "punpcklwd");
485  }
486}
487
488Value *CodeGenFunction::EmitPPCBuiltinExpr(unsigned BuiltinID,
489                                           const CallExpr *E) {
490  switch (BuiltinID) {
491  default: return 0;
492  }
493}
494