clang  7.0.0svn
CGExprScalar.cpp
Go to the documentation of this file.
1 //===--- CGExprScalar.cpp - Emit LLVM Code for Scalar Exprs ---------------===//
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 Expr nodes with scalar LLVM types as LLVM code.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CodeGenFunction.h"
15 #include "CGCleanup.h"
16 #include "CGCXXABI.h"
17 #include "CGDebugInfo.h"
18 #include "CGObjCRuntime.h"
19 #include "CodeGenModule.h"
20 #include "TargetInfo.h"
21 #include "clang/AST/ASTContext.h"
22 #include "clang/AST/DeclObjC.h"
23 #include "clang/AST/Expr.h"
24 #include "clang/AST/RecordLayout.h"
25 #include "clang/AST/StmtVisitor.h"
26 #include "clang/Basic/TargetInfo.h"
28 #include "llvm/ADT/Optional.h"
29 #include "llvm/IR/CFG.h"
30 #include "llvm/IR/Constants.h"
31 #include "llvm/IR/DataLayout.h"
32 #include "llvm/IR/Function.h"
33 #include "llvm/IR/GetElementPtrTypeIterator.h"
34 #include "llvm/IR/GlobalVariable.h"
35 #include "llvm/IR/Intrinsics.h"
36 #include "llvm/IR/Module.h"
37 #include <cstdarg>
38 
39 using namespace clang;
40 using namespace CodeGen;
41 using llvm::Value;
42 
43 //===----------------------------------------------------------------------===//
44 // Scalar Expression Emitter
45 //===----------------------------------------------------------------------===//
46 
47 namespace {
48 
49 /// Determine whether the given binary operation may overflow.
50 /// Sets \p Result to the value of the operation for BO_Add, BO_Sub, BO_Mul,
51 /// and signed BO_{Div,Rem}. For these opcodes, and for unsigned BO_{Div,Rem},
52 /// the returned overflow check is precise. The returned value is 'true' for
53 /// all other opcodes, to be conservative.
54 bool mayHaveIntegerOverflow(llvm::ConstantInt *LHS, llvm::ConstantInt *RHS,
55  BinaryOperator::Opcode Opcode, bool Signed,
56  llvm::APInt &Result) {
57  // Assume overflow is possible, unless we can prove otherwise.
58  bool Overflow = true;
59  const auto &LHSAP = LHS->getValue();
60  const auto &RHSAP = RHS->getValue();
61  if (Opcode == BO_Add) {
62  if (Signed)
63  Result = LHSAP.sadd_ov(RHSAP, Overflow);
64  else
65  Result = LHSAP.uadd_ov(RHSAP, Overflow);
66  } else if (Opcode == BO_Sub) {
67  if (Signed)
68  Result = LHSAP.ssub_ov(RHSAP, Overflow);
69  else
70  Result = LHSAP.usub_ov(RHSAP, Overflow);
71  } else if (Opcode == BO_Mul) {
72  if (Signed)
73  Result = LHSAP.smul_ov(RHSAP, Overflow);
74  else
75  Result = LHSAP.umul_ov(RHSAP, Overflow);
76  } else if (Opcode == BO_Div || Opcode == BO_Rem) {
77  if (Signed && !RHS->isZero())
78  Result = LHSAP.sdiv_ov(RHSAP, Overflow);
79  else
80  return false;
81  }
82  return Overflow;
83 }
84 
85 struct BinOpInfo {
86  Value *LHS;
87  Value *RHS;
88  QualType Ty; // Computation Type.
89  BinaryOperator::Opcode Opcode; // Opcode of BinOp to perform
90  FPOptions FPFeatures;
91  const Expr *E; // Entire expr, for error unsupported. May not be binop.
92 
93  /// Check if the binop can result in integer overflow.
94  bool mayHaveIntegerOverflow() const {
95  // Without constant input, we can't rule out overflow.
96  auto *LHSCI = dyn_cast<llvm::ConstantInt>(LHS);
97  auto *RHSCI = dyn_cast<llvm::ConstantInt>(RHS);
98  if (!LHSCI || !RHSCI)
99  return true;
100 
101  llvm::APInt Result;
102  return ::mayHaveIntegerOverflow(
103  LHSCI, RHSCI, Opcode, Ty->hasSignedIntegerRepresentation(), Result);
104  }
105 
106  /// Check if the binop computes a division or a remainder.
107  bool isDivremOp() const {
108  return Opcode == BO_Div || Opcode == BO_Rem || Opcode == BO_DivAssign ||
109  Opcode == BO_RemAssign;
110  }
111 
112  /// Check if the binop can result in an integer division by zero.
113  bool mayHaveIntegerDivisionByZero() const {
114  if (isDivremOp())
115  if (auto *CI = dyn_cast<llvm::ConstantInt>(RHS))
116  return CI->isZero();
117  return true;
118  }
119 
120  /// Check if the binop can result in a float division by zero.
121  bool mayHaveFloatDivisionByZero() const {
122  if (isDivremOp())
123  if (auto *CFP = dyn_cast<llvm::ConstantFP>(RHS))
124  return CFP->isZero();
125  return true;
126  }
127 };
128 
129 static bool MustVisitNullValue(const Expr *E) {
130  // If a null pointer expression's type is the C++0x nullptr_t, then
131  // it's not necessarily a simple constant and it must be evaluated
132  // for its potential side effects.
133  return E->getType()->isNullPtrType();
134 }
135 
136 /// If \p E is a widened promoted integer, get its base (unpromoted) type.
137 static llvm::Optional<QualType> getUnwidenedIntegerType(const ASTContext &Ctx,
138  const Expr *E) {
139  const Expr *Base = E->IgnoreImpCasts();
140  if (E == Base)
141  return llvm::None;
142 
143  QualType BaseTy = Base->getType();
144  if (!BaseTy->isPromotableIntegerType() ||
145  Ctx.getTypeSize(BaseTy) >= Ctx.getTypeSize(E->getType()))
146  return llvm::None;
147 
148  return BaseTy;
149 }
150 
151 /// Check if \p E is a widened promoted integer.
152 static bool IsWidenedIntegerOp(const ASTContext &Ctx, const Expr *E) {
153  return getUnwidenedIntegerType(Ctx, E).hasValue();
154 }
155 
156 /// Check if we can skip the overflow check for \p Op.
157 static bool CanElideOverflowCheck(const ASTContext &Ctx, const BinOpInfo &Op) {
158  assert((isa<UnaryOperator>(Op.E) || isa<BinaryOperator>(Op.E)) &&
159  "Expected a unary or binary operator");
160 
161  // If the binop has constant inputs and we can prove there is no overflow,
162  // we can elide the overflow check.
163  if (!Op.mayHaveIntegerOverflow())
164  return true;
165 
166  // If a unary op has a widened operand, the op cannot overflow.
167  if (const auto *UO = dyn_cast<UnaryOperator>(Op.E))
168  return !UO->canOverflow();
169 
170  // We usually don't need overflow checks for binops with widened operands.
171  // Multiplication with promoted unsigned operands is a special case.
172  const auto *BO = cast<BinaryOperator>(Op.E);
173  auto OptionalLHSTy = getUnwidenedIntegerType(Ctx, BO->getLHS());
174  if (!OptionalLHSTy)
175  return false;
176 
177  auto OptionalRHSTy = getUnwidenedIntegerType(Ctx, BO->getRHS());
178  if (!OptionalRHSTy)
179  return false;
180 
181  QualType LHSTy = *OptionalLHSTy;
182  QualType RHSTy = *OptionalRHSTy;
183 
184  // This is the simple case: binops without unsigned multiplication, and with
185  // widened operands. No overflow check is needed here.
186  if ((Op.Opcode != BO_Mul && Op.Opcode != BO_MulAssign) ||
187  !LHSTy->isUnsignedIntegerType() || !RHSTy->isUnsignedIntegerType())
188  return true;
189 
190  // For unsigned multiplication the overflow check can be elided if either one
191  // of the unpromoted types are less than half the size of the promoted type.
192  unsigned PromotedSize = Ctx.getTypeSize(Op.E->getType());
193  return (2 * Ctx.getTypeSize(LHSTy)) < PromotedSize ||
194  (2 * Ctx.getTypeSize(RHSTy)) < PromotedSize;
195 }
196 
197 /// Update the FastMathFlags of LLVM IR from the FPOptions in LangOptions.
198 static void updateFastMathFlags(llvm::FastMathFlags &FMF,
199  FPOptions FPFeatures) {
200  FMF.setAllowContract(FPFeatures.allowFPContractAcrossStatement());
201 }
202 
203 /// Propagate fast-math flags from \p Op to the instruction in \p V.
204 static Value *propagateFMFlags(Value *V, const BinOpInfo &Op) {
205  if (auto *I = dyn_cast<llvm::Instruction>(V)) {
206  llvm::FastMathFlags FMF = I->getFastMathFlags();
207  updateFastMathFlags(FMF, Op.FPFeatures);
208  I->setFastMathFlags(FMF);
209  }
210  return V;
211 }
212 
213 class ScalarExprEmitter
214  : public StmtVisitor<ScalarExprEmitter, Value*> {
215  CodeGenFunction &CGF;
216  CGBuilderTy &Builder;
217  bool IgnoreResultAssign;
218  llvm::LLVMContext &VMContext;
219 public:
220 
221  ScalarExprEmitter(CodeGenFunction &cgf, bool ira=false)
222  : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira),
223  VMContext(cgf.getLLVMContext()) {
224  }
225 
226  //===--------------------------------------------------------------------===//
227  // Utilities
228  //===--------------------------------------------------------------------===//
229 
230  bool TestAndClearIgnoreResultAssign() {
231  bool I = IgnoreResultAssign;
232  IgnoreResultAssign = false;
233  return I;
234  }
235 
236  llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); }
237  LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); }
238  LValue EmitCheckedLValue(const Expr *E, CodeGenFunction::TypeCheckKind TCK) {
239  return CGF.EmitCheckedLValue(E, TCK);
240  }
241 
242  void EmitBinOpCheck(ArrayRef<std::pair<Value *, SanitizerMask>> Checks,
243  const BinOpInfo &Info);
244 
245  Value *EmitLoadOfLValue(LValue LV, SourceLocation Loc) {
246  return CGF.EmitLoadOfLValue(LV, Loc).getScalarVal();
247  }
248 
249  void EmitLValueAlignmentAssumption(const Expr *E, Value *V) {
250  const AlignValueAttr *AVAttr = nullptr;
251  if (const auto *DRE = dyn_cast<DeclRefExpr>(E)) {
252  const ValueDecl *VD = DRE->getDecl();
253 
254  if (VD->getType()->isReferenceType()) {
255  if (const auto *TTy =
256  dyn_cast<TypedefType>(VD->getType().getNonReferenceType()))
257  AVAttr = TTy->getDecl()->getAttr<AlignValueAttr>();
258  } else {
259  // Assumptions for function parameters are emitted at the start of the
260  // function, so there is no need to repeat that here.
261  if (isa<ParmVarDecl>(VD))
262  return;
263 
264  AVAttr = VD->getAttr<AlignValueAttr>();
265  }
266  }
267 
268  if (!AVAttr)
269  if (const auto *TTy =
270  dyn_cast<TypedefType>(E->getType()))
271  AVAttr = TTy->getDecl()->getAttr<AlignValueAttr>();
272 
273  if (!AVAttr)
274  return;
275 
276  Value *AlignmentValue = CGF.EmitScalarExpr(AVAttr->getAlignment());
277  llvm::ConstantInt *AlignmentCI = cast<llvm::ConstantInt>(AlignmentValue);
278  CGF.EmitAlignmentAssumption(V, AlignmentCI->getZExtValue());
279  }
280 
281  /// EmitLoadOfLValue - Given an expression with complex type that represents a
282  /// value l-value, this method emits the address of the l-value, then loads
283  /// and returns the result.
284  Value *EmitLoadOfLValue(const Expr *E) {
285  Value *V = EmitLoadOfLValue(EmitCheckedLValue(E, CodeGenFunction::TCK_Load),
286  E->getExprLoc());
287 
288  EmitLValueAlignmentAssumption(E, V);
289  return V;
290  }
291 
292  /// EmitConversionToBool - Convert the specified expression value to a
293  /// boolean (i1) truth value. This is equivalent to "Val != 0".
294  Value *EmitConversionToBool(Value *Src, QualType DstTy);
295 
296  /// Emit a check that a conversion to or from a floating-point type does not
297  /// overflow.
298  void EmitFloatConversionCheck(Value *OrigSrc, QualType OrigSrcType,
299  Value *Src, QualType SrcType, QualType DstType,
300  llvm::Type *DstTy, SourceLocation Loc);
301 
302  /// Emit a conversion from the specified type to the specified destination
303  /// type, both of which are LLVM scalar types.
304  Value *EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy,
305  SourceLocation Loc);
306 
307  Value *EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy,
308  SourceLocation Loc, bool TreatBooleanAsSigned);
309 
310  /// Emit a conversion from the specified complex type to the specified
311  /// destination type, where the destination type is an LLVM scalar type.
312  Value *EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src,
313  QualType SrcTy, QualType DstTy,
314  SourceLocation Loc);
315 
316  /// EmitNullValue - Emit a value that corresponds to null for the given type.
317  Value *EmitNullValue(QualType Ty);
318 
319  /// EmitFloatToBoolConversion - Perform an FP to boolean conversion.
320  Value *EmitFloatToBoolConversion(Value *V) {
321  // Compare against 0.0 for fp scalars.
322  llvm::Value *Zero = llvm::Constant::getNullValue(V->getType());
323  return Builder.CreateFCmpUNE(V, Zero, "tobool");
324  }
325 
326  /// EmitPointerToBoolConversion - Perform a pointer to boolean conversion.
327  Value *EmitPointerToBoolConversion(Value *V, QualType QT) {
328  Value *Zero = CGF.CGM.getNullPointer(cast<llvm::PointerType>(V->getType()), QT);
329 
330  return Builder.CreateICmpNE(V, Zero, "tobool");
331  }
332 
333  Value *EmitIntToBoolConversion(Value *V) {
334  // Because of the type rules of C, we often end up computing a
335  // logical value, then zero extending it to int, then wanting it
336  // as a logical value again. Optimize this common case.
337  if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(V)) {
338  if (ZI->getOperand(0)->getType() == Builder.getInt1Ty()) {
339  Value *Result = ZI->getOperand(0);
340  // If there aren't any more uses, zap the instruction to save space.
341  // Note that there can be more uses, for example if this
342  // is the result of an assignment.
343  if (ZI->use_empty())
344  ZI->eraseFromParent();
345  return Result;
346  }
347  }
348 
349  return Builder.CreateIsNotNull(V, "tobool");
350  }
351 
352  //===--------------------------------------------------------------------===//
353  // Visitor Methods
354  //===--------------------------------------------------------------------===//
355 
356  Value *Visit(Expr *E) {
357  ApplyDebugLocation DL(CGF, E);
359  }
360 
361  Value *VisitStmt(Stmt *S) {
362  S->dump(CGF.getContext().getSourceManager());
363  llvm_unreachable("Stmt can't have complex result type!");
364  }
365  Value *VisitExpr(Expr *S);
366 
367  Value *VisitParenExpr(ParenExpr *PE) {
368  return Visit(PE->getSubExpr());
369  }
370  Value *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) {
371  return Visit(E->getReplacement());
372  }
373  Value *VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
374  return Visit(GE->getResultExpr());
375  }
376  Value *VisitCoawaitExpr(CoawaitExpr *S) {
377  return CGF.EmitCoawaitExpr(*S).getScalarVal();
378  }
379  Value *VisitCoyieldExpr(CoyieldExpr *S) {
380  return CGF.EmitCoyieldExpr(*S).getScalarVal();
381  }
382  Value *VisitUnaryCoawait(const UnaryOperator *E) {
383  return Visit(E->getSubExpr());
384  }
385 
386  // Leaves.
387  Value *VisitIntegerLiteral(const IntegerLiteral *E) {
388  return Builder.getInt(E->getValue());
389  }
390  Value *VisitFloatingLiteral(const FloatingLiteral *E) {
391  return llvm::ConstantFP::get(VMContext, E->getValue());
392  }
393  Value *VisitCharacterLiteral(const CharacterLiteral *E) {
394  return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
395  }
396  Value *VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *E) {
397  return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
398  }
399  Value *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
400  return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
401  }
402  Value *VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) {
403  return EmitNullValue(E->getType());
404  }
405  Value *VisitGNUNullExpr(const GNUNullExpr *E) {
406  return EmitNullValue(E->getType());
407  }
408  Value *VisitOffsetOfExpr(OffsetOfExpr *E);
409  Value *VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
410  Value *VisitAddrLabelExpr(const AddrLabelExpr *E) {
411  llvm::Value *V = CGF.GetAddrOfLabel(E->getLabel());
412  return Builder.CreateBitCast(V, ConvertType(E->getType()));
413  }
414 
415  Value *VisitSizeOfPackExpr(SizeOfPackExpr *E) {
416  return llvm::ConstantInt::get(ConvertType(E->getType()),E->getPackLength());
417  }
418 
419  Value *VisitPseudoObjectExpr(PseudoObjectExpr *E) {
420  return CGF.EmitPseudoObjectRValue(E).getScalarVal();
421  }
422 
423  Value *VisitOpaqueValueExpr(OpaqueValueExpr *E) {
424  if (E->isGLValue())
425  return EmitLoadOfLValue(CGF.getOrCreateOpaqueLValueMapping(E),
426  E->getExprLoc());
427 
428  // Otherwise, assume the mapping is the scalar directly.
430  }
431 
432  Value *emitConstant(const CodeGenFunction::ConstantEmission &Constant,
433  Expr *E) {
434  assert(Constant && "not a constant");
435  if (Constant.isReference())
436  return EmitLoadOfLValue(Constant.getReferenceLValue(CGF, E),
437  E->getExprLoc());
438  return Constant.getValue();
439  }
440 
441  // l-values.
442  Value *VisitDeclRefExpr(DeclRefExpr *E) {
444  return emitConstant(Constant, E);
445  return EmitLoadOfLValue(E);
446  }
447 
448  Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
449  return CGF.EmitObjCSelectorExpr(E);
450  }
451  Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
452  return CGF.EmitObjCProtocolExpr(E);
453  }
454  Value *VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
455  return EmitLoadOfLValue(E);
456  }
457  Value *VisitObjCMessageExpr(ObjCMessageExpr *E) {
458  if (E->getMethodDecl() &&
460  return EmitLoadOfLValue(E);
461  return CGF.EmitObjCMessageExpr(E).getScalarVal();
462  }
463 
464  Value *VisitObjCIsaExpr(ObjCIsaExpr *E) {
465  LValue LV = CGF.EmitObjCIsaExpr(E);
466  Value *V = CGF.EmitLoadOfLValue(LV, E->getExprLoc()).getScalarVal();
467  return V;
468  }
469 
470  Value *VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
471  VersionTuple Version = E->getVersion();
472 
473  // If we're checking for a platform older than our minimum deployment
474  // target, we can fold the check away.
475  if (Version <= CGF.CGM.getTarget().getPlatformMinVersion())
476  return llvm::ConstantInt::get(Builder.getInt1Ty(), 1);
477 
478  Optional<unsigned> Min = Version.getMinor(), SMin = Version.getSubminor();
479  llvm::Value *Args[] = {
480  llvm::ConstantInt::get(CGF.CGM.Int32Ty, Version.getMajor()),
481  llvm::ConstantInt::get(CGF.CGM.Int32Ty, Min ? *Min : 0),
482  llvm::ConstantInt::get(CGF.CGM.Int32Ty, SMin ? *SMin : 0),
483  };
484 
485  return CGF.EmitBuiltinAvailable(Args);
486  }
487 
488  Value *VisitArraySubscriptExpr(ArraySubscriptExpr *E);
489  Value *VisitShuffleVectorExpr(ShuffleVectorExpr *E);
490  Value *VisitConvertVectorExpr(ConvertVectorExpr *E);
491  Value *VisitMemberExpr(MemberExpr *E);
492  Value *VisitExtVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); }
493  Value *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
494  return EmitLoadOfLValue(E);
495  }
496 
497  Value *VisitInitListExpr(InitListExpr *E);
498 
499  Value *VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
500  assert(CGF.getArrayInitIndex() &&
501  "ArrayInitIndexExpr not inside an ArrayInitLoopExpr?");
502  return CGF.getArrayInitIndex();
503  }
504 
505  Value *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
506  return EmitNullValue(E->getType());
507  }
508  Value *VisitExplicitCastExpr(ExplicitCastExpr *E) {
509  CGF.CGM.EmitExplicitCastExprType(E, &CGF);
510  return VisitCastExpr(E);
511  }
512  Value *VisitCastExpr(CastExpr *E);
513 
514  Value *VisitCallExpr(const CallExpr *E) {
515  if (E->getCallReturnType(CGF.getContext())->isReferenceType())
516  return EmitLoadOfLValue(E);
517 
518  Value *V = CGF.EmitCallExpr(E).getScalarVal();
519 
520  EmitLValueAlignmentAssumption(E, V);
521  return V;
522  }
523 
524  Value *VisitStmtExpr(const StmtExpr *E);
525 
526  // Unary Operators.
527  Value *VisitUnaryPostDec(const UnaryOperator *E) {
528  LValue LV = EmitLValue(E->getSubExpr());
529  return EmitScalarPrePostIncDec(E, LV, false, false);
530  }
531  Value *VisitUnaryPostInc(const UnaryOperator *E) {
532  LValue LV = EmitLValue(E->getSubExpr());
533  return EmitScalarPrePostIncDec(E, LV, true, false);
534  }
535  Value *VisitUnaryPreDec(const UnaryOperator *E) {
536  LValue LV = EmitLValue(E->getSubExpr());
537  return EmitScalarPrePostIncDec(E, LV, false, true);
538  }
539  Value *VisitUnaryPreInc(const UnaryOperator *E) {
540  LValue LV = EmitLValue(E->getSubExpr());
541  return EmitScalarPrePostIncDec(E, LV, true, true);
542  }
543 
544  llvm::Value *EmitIncDecConsiderOverflowBehavior(const UnaryOperator *E,
545  llvm::Value *InVal,
546  bool IsInc);
547 
548  llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
549  bool isInc, bool isPre);
550 
551 
552  Value *VisitUnaryAddrOf(const UnaryOperator *E) {
553  if (isa<MemberPointerType>(E->getType())) // never sugared
554  return CGF.CGM.getMemberPointerConstant(E);
555 
556  return EmitLValue(E->getSubExpr()).getPointer();
557  }
558  Value *VisitUnaryDeref(const UnaryOperator *E) {
559  if (E->getType()->isVoidType())
560  return Visit(E->getSubExpr()); // the actual value should be unused
561  return EmitLoadOfLValue(E);
562  }
563  Value *VisitUnaryPlus(const UnaryOperator *E) {
564  // This differs from gcc, though, most likely due to a bug in gcc.
565  TestAndClearIgnoreResultAssign();
566  return Visit(E->getSubExpr());
567  }
568  Value *VisitUnaryMinus (const UnaryOperator *E);
569  Value *VisitUnaryNot (const UnaryOperator *E);
570  Value *VisitUnaryLNot (const UnaryOperator *E);
571  Value *VisitUnaryReal (const UnaryOperator *E);
572  Value *VisitUnaryImag (const UnaryOperator *E);
573  Value *VisitUnaryExtension(const UnaryOperator *E) {
574  return Visit(E->getSubExpr());
575  }
576 
577  // C++
578  Value *VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E) {
579  return EmitLoadOfLValue(E);
580  }
581 
582  Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
583  return Visit(DAE->getExpr());
584  }
585  Value *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
587  return Visit(DIE->getExpr());
588  }
589  Value *VisitCXXThisExpr(CXXThisExpr *TE) {
590  return CGF.LoadCXXThis();
591  }
592 
593  Value *VisitExprWithCleanups(ExprWithCleanups *E);
594  Value *VisitCXXNewExpr(const CXXNewExpr *E) {
595  return CGF.EmitCXXNewExpr(E);
596  }
597  Value *VisitCXXDeleteExpr(const CXXDeleteExpr *E) {
598  CGF.EmitCXXDeleteExpr(E);
599  return nullptr;
600  }
601 
602  Value *VisitTypeTraitExpr(const TypeTraitExpr *E) {
603  return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
604  }
605 
606  Value *VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
607  return llvm::ConstantInt::get(Builder.getInt32Ty(), E->getValue());
608  }
609 
610  Value *VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
611  return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue());
612  }
613 
614  Value *VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E) {
615  // C++ [expr.pseudo]p1:
616  // The result shall only be used as the operand for the function call
617  // operator (), and the result of such a call has type void. The only
618  // effect is the evaluation of the postfix-expression before the dot or
619  // arrow.
620  CGF.EmitScalarExpr(E->getBase());
621  return nullptr;
622  }
623 
624  Value *VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) {
625  return EmitNullValue(E->getType());
626  }
627 
628  Value *VisitCXXThrowExpr(const CXXThrowExpr *E) {
629  CGF.EmitCXXThrowExpr(E);
630  return nullptr;
631  }
632 
633  Value *VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) {
634  return Builder.getInt1(E->getValue());
635  }
636 
637  // Binary Operators.
638  Value *EmitMul(const BinOpInfo &Ops) {
639  if (Ops.Ty->isSignedIntegerOrEnumerationType()) {
640  switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
642  return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
644  if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
645  return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
646  // Fall through.
648  if (CanElideOverflowCheck(CGF.getContext(), Ops))
649  return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
650  return EmitOverflowCheckedBinOp(Ops);
651  }
652  }
653 
654  if (Ops.Ty->isUnsignedIntegerType() &&
655  CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) &&
656  !CanElideOverflowCheck(CGF.getContext(), Ops))
657  return EmitOverflowCheckedBinOp(Ops);
658 
659  if (Ops.LHS->getType()->isFPOrFPVectorTy()) {
660  Value *V = Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul");
661  return propagateFMFlags(V, Ops);
662  }
663  return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
664  }
665  /// Create a binary op that checks for overflow.
666  /// Currently only supports +, - and *.
667  Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops);
668 
669  // Check for undefined division and modulus behaviors.
670  void EmitUndefinedBehaviorIntegerDivAndRemCheck(const BinOpInfo &Ops,
671  llvm::Value *Zero,bool isDiv);
672  // Common helper for getting how wide LHS of shift is.
673  static Value *GetWidthMinusOneValue(Value* LHS,Value* RHS);
674  Value *EmitDiv(const BinOpInfo &Ops);
675  Value *EmitRem(const BinOpInfo &Ops);
676  Value *EmitAdd(const BinOpInfo &Ops);
677  Value *EmitSub(const BinOpInfo &Ops);
678  Value *EmitShl(const BinOpInfo &Ops);
679  Value *EmitShr(const BinOpInfo &Ops);
680  Value *EmitAnd(const BinOpInfo &Ops) {
681  return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and");
682  }
683  Value *EmitXor(const BinOpInfo &Ops) {
684  return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor");
685  }
686  Value *EmitOr (const BinOpInfo &Ops) {
687  return Builder.CreateOr(Ops.LHS, Ops.RHS, "or");
688  }
689 
690  BinOpInfo EmitBinOps(const BinaryOperator *E);
691  LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E,
692  Value *(ScalarExprEmitter::*F)(const BinOpInfo &),
693  Value *&Result);
694 
695  Value *EmitCompoundAssign(const CompoundAssignOperator *E,
696  Value *(ScalarExprEmitter::*F)(const BinOpInfo &));
697 
698  // Binary operators and binary compound assignment operators.
699 #define HANDLEBINOP(OP) \
700  Value *VisitBin ## OP(const BinaryOperator *E) { \
701  return Emit ## OP(EmitBinOps(E)); \
702  } \
703  Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \
704  return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \
705  }
706  HANDLEBINOP(Mul)
707  HANDLEBINOP(Div)
708  HANDLEBINOP(Rem)
709  HANDLEBINOP(Add)
710  HANDLEBINOP(Sub)
711  HANDLEBINOP(Shl)
712  HANDLEBINOP(Shr)
714  HANDLEBINOP(Xor)
715  HANDLEBINOP(Or)
716 #undef HANDLEBINOP
717 
718  // Comparisons.
719  Value *EmitCompare(const BinaryOperator *E, llvm::CmpInst::Predicate UICmpOpc,
720  llvm::CmpInst::Predicate SICmpOpc,
721  llvm::CmpInst::Predicate FCmpOpc);
722 #define VISITCOMP(CODE, UI, SI, FP) \
723  Value *VisitBin##CODE(const BinaryOperator *E) { \
724  return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \
725  llvm::FCmpInst::FP); }
726  VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT)
727  VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT)
728  VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE)
729  VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE)
730  VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ)
731  VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE)
732 #undef VISITCOMP
733 
734  Value *VisitBinAssign (const BinaryOperator *E);
735 
736  Value *VisitBinLAnd (const BinaryOperator *E);
737  Value *VisitBinLOr (const BinaryOperator *E);
738  Value *VisitBinComma (const BinaryOperator *E);
739 
740  Value *VisitBinPtrMemD(const Expr *E) { return EmitLoadOfLValue(E); }
741  Value *VisitBinPtrMemI(const Expr *E) { return EmitLoadOfLValue(E); }
742 
743  // Other Operators.
744  Value *VisitBlockExpr(const BlockExpr *BE);
745  Value *VisitAbstractConditionalOperator(const AbstractConditionalOperator *);
746  Value *VisitChooseExpr(ChooseExpr *CE);
747  Value *VisitVAArgExpr(VAArgExpr *VE);
748  Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) {
749  return CGF.EmitObjCStringLiteral(E);
750  }
751  Value *VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
752  return CGF.EmitObjCBoxedExpr(E);
753  }
754  Value *VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
755  return CGF.EmitObjCArrayLiteral(E);
756  }
757  Value *VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
758  return CGF.EmitObjCDictionaryLiteral(E);
759  }
760  Value *VisitAsTypeExpr(AsTypeExpr *CE);
761  Value *VisitAtomicExpr(AtomicExpr *AE);
762 };
763 } // end anonymous namespace.
764 
765 //===----------------------------------------------------------------------===//
766 // Utilities
767 //===----------------------------------------------------------------------===//
768 
769 /// EmitConversionToBool - Convert the specified expression value to a
770 /// boolean (i1) truth value. This is equivalent to "Val != 0".
771 Value *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) {
772  assert(SrcType.isCanonical() && "EmitScalarConversion strips typedefs");
773 
774  if (SrcType->isRealFloatingType())
775  return EmitFloatToBoolConversion(Src);
776 
777  if (const MemberPointerType *MPT = dyn_cast<MemberPointerType>(SrcType))
778  return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, Src, MPT);
779 
780  assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) &&
781  "Unknown scalar type to convert");
782 
783  if (isa<llvm::IntegerType>(Src->getType()))
784  return EmitIntToBoolConversion(Src);
785 
786  assert(isa<llvm::PointerType>(Src->getType()));
787  return EmitPointerToBoolConversion(Src, SrcType);
788 }
789 
790 void ScalarExprEmitter::EmitFloatConversionCheck(
791  Value *OrigSrc, QualType OrigSrcType, Value *Src, QualType SrcType,
792  QualType DstType, llvm::Type *DstTy, SourceLocation Loc) {
793  CodeGenFunction::SanitizerScope SanScope(&CGF);
794  using llvm::APFloat;
795  using llvm::APSInt;
796 
797  llvm::Type *SrcTy = Src->getType();
798 
799  llvm::Value *Check = nullptr;
800  if (llvm::IntegerType *IntTy = dyn_cast<llvm::IntegerType>(SrcTy)) {
801  // Integer to floating-point. This can fail for unsigned short -> __half
802  // or unsigned __int128 -> float.
803  assert(DstType->isFloatingType());
804  bool SrcIsUnsigned = OrigSrcType->isUnsignedIntegerOrEnumerationType();
805 
806  APFloat LargestFloat =
807  APFloat::getLargest(CGF.getContext().getFloatTypeSemantics(DstType));
808  APSInt LargestInt(IntTy->getBitWidth(), SrcIsUnsigned);
809 
810  bool IsExact;
811  if (LargestFloat.convertToInteger(LargestInt, APFloat::rmTowardZero,
812  &IsExact) != APFloat::opOK)
813  // The range of representable values of this floating point type includes
814  // all values of this integer type. Don't need an overflow check.
815  return;
816 
817  llvm::Value *Max = llvm::ConstantInt::get(VMContext, LargestInt);
818  if (SrcIsUnsigned)
819  Check = Builder.CreateICmpULE(Src, Max);
820  else {
821  llvm::Value *Min = llvm::ConstantInt::get(VMContext, -LargestInt);
822  llvm::Value *GE = Builder.CreateICmpSGE(Src, Min);
823  llvm::Value *LE = Builder.CreateICmpSLE(Src, Max);
824  Check = Builder.CreateAnd(GE, LE);
825  }
826  } else {
827  const llvm::fltSemantics &SrcSema =
828  CGF.getContext().getFloatTypeSemantics(OrigSrcType);
829  if (isa<llvm::IntegerType>(DstTy)) {
830  // Floating-point to integer. This has undefined behavior if the source is
831  // +-Inf, NaN, or doesn't fit into the destination type (after truncation
832  // to an integer).
833  unsigned Width = CGF.getContext().getIntWidth(DstType);
834  bool Unsigned = DstType->isUnsignedIntegerOrEnumerationType();
835 
836  APSInt Min = APSInt::getMinValue(Width, Unsigned);
837  APFloat MinSrc(SrcSema, APFloat::uninitialized);
838  if (MinSrc.convertFromAPInt(Min, !Unsigned, APFloat::rmTowardZero) &
839  APFloat::opOverflow)
840  // Don't need an overflow check for lower bound. Just check for
841  // -Inf/NaN.
842  MinSrc = APFloat::getInf(SrcSema, true);
843  else
844  // Find the largest value which is too small to represent (before
845  // truncation toward zero).
846  MinSrc.subtract(APFloat(SrcSema, 1), APFloat::rmTowardNegative);
847 
848  APSInt Max = APSInt::getMaxValue(Width, Unsigned);
849  APFloat MaxSrc(SrcSema, APFloat::uninitialized);
850  if (MaxSrc.convertFromAPInt(Max, !Unsigned, APFloat::rmTowardZero) &
851  APFloat::opOverflow)
852  // Don't need an overflow check for upper bound. Just check for
853  // +Inf/NaN.
854  MaxSrc = APFloat::getInf(SrcSema, false);
855  else
856  // Find the smallest value which is too large to represent (before
857  // truncation toward zero).
858  MaxSrc.add(APFloat(SrcSema, 1), APFloat::rmTowardPositive);
859 
860  // If we're converting from __half, convert the range to float to match
861  // the type of src.
862  if (OrigSrcType->isHalfType()) {
863  const llvm::fltSemantics &Sema =
864  CGF.getContext().getFloatTypeSemantics(SrcType);
865  bool IsInexact;
866  MinSrc.convert(Sema, APFloat::rmTowardZero, &IsInexact);
867  MaxSrc.convert(Sema, APFloat::rmTowardZero, &IsInexact);
868  }
869 
870  llvm::Value *GE =
871  Builder.CreateFCmpOGT(Src, llvm::ConstantFP::get(VMContext, MinSrc));
872  llvm::Value *LE =
873  Builder.CreateFCmpOLT(Src, llvm::ConstantFP::get(VMContext, MaxSrc));
874  Check = Builder.CreateAnd(GE, LE);
875  } else {
876  // FIXME: Maybe split this sanitizer out from float-cast-overflow.
877  //
878  // Floating-point to floating-point. This has undefined behavior if the
879  // source is not in the range of representable values of the destination
880  // type. The C and C++ standards are spectacularly unclear here. We
881  // diagnose finite out-of-range conversions, but allow infinities and NaNs
882  // to convert to the corresponding value in the smaller type.
883  //
884  // C11 Annex F gives all such conversions defined behavior for IEC 60559
885  // conforming implementations. Unfortunately, LLVM's fptrunc instruction
886  // does not.
887 
888  // Converting from a lower rank to a higher rank can never have
889  // undefined behavior, since higher-rank types must have a superset
890  // of values of lower-rank types.
891  if (CGF.getContext().getFloatingTypeOrder(OrigSrcType, DstType) != 1)
892  return;
893 
894  assert(!OrigSrcType->isHalfType() &&
895  "should not check conversion from __half, it has the lowest rank");
896 
897  const llvm::fltSemantics &DstSema =
898  CGF.getContext().getFloatTypeSemantics(DstType);
899  APFloat MinBad = APFloat::getLargest(DstSema, false);
900  APFloat MaxBad = APFloat::getInf(DstSema, false);
901 
902  bool IsInexact;
903  MinBad.convert(SrcSema, APFloat::rmTowardZero, &IsInexact);
904  MaxBad.convert(SrcSema, APFloat::rmTowardZero, &IsInexact);
905 
906  Value *AbsSrc = CGF.EmitNounwindRuntimeCall(
907  CGF.CGM.getIntrinsic(llvm::Intrinsic::fabs, Src->getType()), Src);
908  llvm::Value *GE =
909  Builder.CreateFCmpOGT(AbsSrc, llvm::ConstantFP::get(VMContext, MinBad));
910  llvm::Value *LE =
911  Builder.CreateFCmpOLT(AbsSrc, llvm::ConstantFP::get(VMContext, MaxBad));
912  Check = Builder.CreateNot(Builder.CreateAnd(GE, LE));
913  }
914  }
915 
916  llvm::Constant *StaticArgs[] = {CGF.EmitCheckSourceLocation(Loc),
917  CGF.EmitCheckTypeDescriptor(OrigSrcType),
918  CGF.EmitCheckTypeDescriptor(DstType)};
919  CGF.EmitCheck(std::make_pair(Check, SanitizerKind::FloatCastOverflow),
920  SanitizerHandler::FloatCastOverflow, StaticArgs, OrigSrc);
921 }
922 
923 /// Emit a conversion from the specified type to the specified destination type,
924 /// both of which are LLVM scalar types.
925 Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
926  QualType DstType,
927  SourceLocation Loc) {
928  return EmitScalarConversion(Src, SrcType, DstType, Loc, false);
929 }
930 
931 Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
932  QualType DstType,
933  SourceLocation Loc,
934  bool TreatBooleanAsSigned) {
935  SrcType = CGF.getContext().getCanonicalType(SrcType);
936  DstType = CGF.getContext().getCanonicalType(DstType);
937  if (SrcType == DstType) return Src;
938 
939  if (DstType->isVoidType()) return nullptr;
940 
941  llvm::Value *OrigSrc = Src;
942  QualType OrigSrcType = SrcType;
943  llvm::Type *SrcTy = Src->getType();
944 
945  // Handle conversions to bool first, they are special: comparisons against 0.
946  if (DstType->isBooleanType())
947  return EmitConversionToBool(Src, SrcType);
948 
949  llvm::Type *DstTy = ConvertType(DstType);
950 
951  // Cast from half through float if half isn't a native type.
952  if (SrcType->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
953  // Cast to FP using the intrinsic if the half type itself isn't supported.
954  if (DstTy->isFloatingPointTy()) {
956  return Builder.CreateCall(
957  CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16, DstTy),
958  Src);
959  } else {
960  // Cast to other types through float, using either the intrinsic or FPExt,
961  // depending on whether the half type itself is supported
962  // (as opposed to operations on half, available with NativeHalfType).
964  Src = Builder.CreateCall(
965  CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16,
966  CGF.CGM.FloatTy),
967  Src);
968  } else {
969  Src = Builder.CreateFPExt(Src, CGF.CGM.FloatTy, "conv");
970  }
971  SrcType = CGF.getContext().FloatTy;
972  SrcTy = CGF.FloatTy;
973  }
974  }
975 
976  // Ignore conversions like int -> uint.
977  if (SrcTy == DstTy)
978  return Src;
979 
980  // Handle pointer conversions next: pointers can only be converted to/from
981  // other pointers and integers. Check for pointer types in terms of LLVM, as
982  // some native types (like Obj-C id) may map to a pointer type.
983  if (auto DstPT = dyn_cast<llvm::PointerType>(DstTy)) {
984  // The source value may be an integer, or a pointer.
985  if (isa<llvm::PointerType>(SrcTy))
986  return Builder.CreateBitCast(Src, DstTy, "conv");
987 
988  assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?");
989  // First, convert to the correct width so that we control the kind of
990  // extension.
991  llvm::Type *MiddleTy = CGF.CGM.getDataLayout().getIntPtrType(DstPT);
992  bool InputSigned = SrcType->isSignedIntegerOrEnumerationType();
993  llvm::Value* IntResult =
994  Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv");
995  // Then, cast to pointer.
996  return Builder.CreateIntToPtr(IntResult, DstTy, "conv");
997  }
998 
999  if (isa<llvm::PointerType>(SrcTy)) {
1000  // Must be an ptr to int cast.
1001  assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?");
1002  return Builder.CreatePtrToInt(Src, DstTy, "conv");
1003  }
1004 
1005  // A scalar can be splatted to an extended vector of the same element type
1006  if (DstType->isExtVectorType() && !SrcType->isVectorType()) {
1007  // Sema should add casts to make sure that the source expression's type is
1008  // the same as the vector's element type (sans qualifiers)
1009  assert(DstType->castAs<ExtVectorType>()->getElementType().getTypePtr() ==
1010  SrcType.getTypePtr() &&
1011  "Splatted expr doesn't match with vector element type?");
1012 
1013  // Splat the element across to all elements
1014  unsigned NumElements = DstTy->getVectorNumElements();
1015  return Builder.CreateVectorSplat(NumElements, Src, "splat");
1016  }
1017 
1018  if (isa<llvm::VectorType>(SrcTy) || isa<llvm::VectorType>(DstTy)) {
1019  // Allow bitcast from vector to integer/fp of the same size.
1020  unsigned SrcSize = SrcTy->getPrimitiveSizeInBits();
1021  unsigned DstSize = DstTy->getPrimitiveSizeInBits();
1022  if (SrcSize == DstSize)
1023  return Builder.CreateBitCast(Src, DstTy, "conv");
1024 
1025  // Conversions between vectors of different sizes are not allowed except
1026  // when vectors of half are involved. Operations on storage-only half
1027  // vectors require promoting half vector operands to float vectors and
1028  // truncating the result, which is either an int or float vector, to a
1029  // short or half vector.
1030 
1031  // Source and destination are both expected to be vectors.
1032  llvm::Type *SrcElementTy = SrcTy->getVectorElementType();
1033  llvm::Type *DstElementTy = DstTy->getVectorElementType();
1034  (void)DstElementTy;
1035 
1036  assert(((SrcElementTy->isIntegerTy() &&
1037  DstElementTy->isIntegerTy()) ||
1038  (SrcElementTy->isFloatingPointTy() &&
1039  DstElementTy->isFloatingPointTy())) &&
1040  "unexpected conversion between a floating-point vector and an "
1041  "integer vector");
1042 
1043  // Truncate an i32 vector to an i16 vector.
1044  if (SrcElementTy->isIntegerTy())
1045  return Builder.CreateIntCast(Src, DstTy, false, "conv");
1046 
1047  // Truncate a float vector to a half vector.
1048  if (SrcSize > DstSize)
1049  return Builder.CreateFPTrunc(Src, DstTy, "conv");
1050 
1051  // Promote a half vector to a float vector.
1052  return Builder.CreateFPExt(Src, DstTy, "conv");
1053  }
1054 
1055  // Finally, we have the arithmetic types: real int/float.
1056  Value *Res = nullptr;
1057  llvm::Type *ResTy = DstTy;
1058 
1059  // An overflowing conversion has undefined behavior if either the source type
1060  // or the destination type is a floating-point type.
1061  if (CGF.SanOpts.has(SanitizerKind::FloatCastOverflow) &&
1062  (OrigSrcType->isFloatingType() || DstType->isFloatingType()))
1063  EmitFloatConversionCheck(OrigSrc, OrigSrcType, Src, SrcType, DstType, DstTy,
1064  Loc);
1065 
1066  // Cast to half through float if half isn't a native type.
1067  if (DstType->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
1068  // Make sure we cast in a single step if from another FP type.
1069  if (SrcTy->isFloatingPointTy()) {
1070  // Use the intrinsic if the half type itself isn't supported
1071  // (as opposed to operations on half, available with NativeHalfType).
1073  return Builder.CreateCall(
1074  CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16, SrcTy), Src);
1075  // If the half type is supported, just use an fptrunc.
1076  return Builder.CreateFPTrunc(Src, DstTy);
1077  }
1078  DstTy = CGF.FloatTy;
1079  }
1080 
1081  if (isa<llvm::IntegerType>(SrcTy)) {
1082  bool InputSigned = SrcType->isSignedIntegerOrEnumerationType();
1083  if (SrcType->isBooleanType() && TreatBooleanAsSigned) {
1084  InputSigned = true;
1085  }
1086  if (isa<llvm::IntegerType>(DstTy))
1087  Res = Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
1088  else if (InputSigned)
1089  Res = Builder.CreateSIToFP(Src, DstTy, "conv");
1090  else
1091  Res = Builder.CreateUIToFP(Src, DstTy, "conv");
1092  } else if (isa<llvm::IntegerType>(DstTy)) {
1093  assert(SrcTy->isFloatingPointTy() && "Unknown real conversion");
1094  if (DstType->isSignedIntegerOrEnumerationType())
1095  Res = Builder.CreateFPToSI(Src, DstTy, "conv");
1096  else
1097  Res = Builder.CreateFPToUI(Src, DstTy, "conv");
1098  } else {
1099  assert(SrcTy->isFloatingPointTy() && DstTy->isFloatingPointTy() &&
1100  "Unknown real conversion");
1101  if (DstTy->getTypeID() < SrcTy->getTypeID())
1102  Res = Builder.CreateFPTrunc(Src, DstTy, "conv");
1103  else
1104  Res = Builder.CreateFPExt(Src, DstTy, "conv");
1105  }
1106 
1107  if (DstTy != ResTy) {
1109  assert(ResTy->isIntegerTy(16) && "Only half FP requires extra conversion");
1110  Res = Builder.CreateCall(
1111  CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16, CGF.CGM.FloatTy),
1112  Res);
1113  } else {
1114  Res = Builder.CreateFPTrunc(Res, ResTy, "conv");
1115  }
1116  }
1117 
1118  return Res;
1119 }
1120 
1121 /// Emit a conversion from the specified complex type to the specified
1122 /// destination type, where the destination type is an LLVM scalar type.
1123 Value *ScalarExprEmitter::EmitComplexToScalarConversion(
1125  SourceLocation Loc) {
1126  // Get the source element type.
1127  SrcTy = SrcTy->castAs<ComplexType>()->getElementType();
1128 
1129  // Handle conversions to bool first, they are special: comparisons against 0.
1130  if (DstTy->isBooleanType()) {
1131  // Complex != 0 -> (Real != 0) | (Imag != 0)
1132  Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy, Loc);
1133  Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy, Loc);
1134  return Builder.CreateOr(Src.first, Src.second, "tobool");
1135  }
1136 
1137  // C99 6.3.1.7p2: "When a value of complex type is converted to a real type,
1138  // the imaginary part of the complex value is discarded and the value of the
1139  // real part is converted according to the conversion rules for the
1140  // corresponding real type.
1141  return EmitScalarConversion(Src.first, SrcTy, DstTy, Loc);
1142 }
1143 
1144 Value *ScalarExprEmitter::EmitNullValue(QualType Ty) {
1145  return CGF.EmitFromMemory(CGF.CGM.EmitNullConstant(Ty), Ty);
1146 }
1147 
1148 /// Emit a sanitization check for the given "binary" operation (which
1149 /// might actually be a unary increment which has been lowered to a binary
1150 /// operation). The check passes if all values in \p Checks (which are \c i1),
1151 /// are \c true.
1152 void ScalarExprEmitter::EmitBinOpCheck(
1153  ArrayRef<std::pair<Value *, SanitizerMask>> Checks, const BinOpInfo &Info) {
1154  assert(CGF.IsSanitizerScope);
1155  SanitizerHandler Check;
1157  SmallVector<llvm::Value *, 2> DynamicData;
1158 
1159  BinaryOperatorKind Opcode = Info.Opcode;
1162 
1163  StaticData.push_back(CGF.EmitCheckSourceLocation(Info.E->getExprLoc()));
1164  const UnaryOperator *UO = dyn_cast<UnaryOperator>(Info.E);
1165  if (UO && UO->getOpcode() == UO_Minus) {
1166  Check = SanitizerHandler::NegateOverflow;
1167  StaticData.push_back(CGF.EmitCheckTypeDescriptor(UO->getType()));
1168  DynamicData.push_back(Info.RHS);
1169  } else {
1170  if (BinaryOperator::isShiftOp(Opcode)) {
1171  // Shift LHS negative or too large, or RHS out of bounds.
1172  Check = SanitizerHandler::ShiftOutOfBounds;
1173  const BinaryOperator *BO = cast<BinaryOperator>(Info.E);
1174  StaticData.push_back(
1175  CGF.EmitCheckTypeDescriptor(BO->getLHS()->getType()));
1176  StaticData.push_back(
1177  CGF.EmitCheckTypeDescriptor(BO->getRHS()->getType()));
1178  } else if (Opcode == BO_Div || Opcode == BO_Rem) {
1179  // Divide or modulo by zero, or signed overflow (eg INT_MAX / -1).
1180  Check = SanitizerHandler::DivremOverflow;
1181  StaticData.push_back(CGF.EmitCheckTypeDescriptor(Info.Ty));
1182  } else {
1183  // Arithmetic overflow (+, -, *).
1184  switch (Opcode) {
1185  case BO_Add: Check = SanitizerHandler::AddOverflow; break;
1186  case BO_Sub: Check = SanitizerHandler::SubOverflow; break;
1187  case BO_Mul: Check = SanitizerHandler::MulOverflow; break;
1188  default: llvm_unreachable("unexpected opcode for bin op check");
1189  }
1190  StaticData.push_back(CGF.EmitCheckTypeDescriptor(Info.Ty));
1191  }
1192  DynamicData.push_back(Info.LHS);
1193  DynamicData.push_back(Info.RHS);
1194  }
1195 
1196  CGF.EmitCheck(Checks, Check, StaticData, DynamicData);
1197 }
1198 
1199 //===----------------------------------------------------------------------===//
1200 // Visitor Methods
1201 //===----------------------------------------------------------------------===//
1202 
1203 Value *ScalarExprEmitter::VisitExpr(Expr *E) {
1204  CGF.ErrorUnsupported(E, "scalar expression");
1205  if (E->getType()->isVoidType())
1206  return nullptr;
1207  return llvm::UndefValue::get(CGF.ConvertType(E->getType()));
1208 }
1209 
1210 Value *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
1211  // Vector Mask Case
1212  if (E->getNumSubExprs() == 2) {
1213  Value *LHS = CGF.EmitScalarExpr(E->getExpr(0));
1214  Value *RHS = CGF.EmitScalarExpr(E->getExpr(1));
1215  Value *Mask;
1216 
1217  llvm::VectorType *LTy = cast<llvm::VectorType>(LHS->getType());
1218  unsigned LHSElts = LTy->getNumElements();
1219 
1220  Mask = RHS;
1221 
1222  llvm::VectorType *MTy = cast<llvm::VectorType>(Mask->getType());
1223 
1224  // Mask off the high bits of each shuffle index.
1225  Value *MaskBits =
1226  llvm::ConstantInt::get(MTy, llvm::NextPowerOf2(LHSElts - 1) - 1);
1227  Mask = Builder.CreateAnd(Mask, MaskBits, "mask");
1228 
1229  // newv = undef
1230  // mask = mask & maskbits
1231  // for each elt
1232  // n = extract mask i
1233  // x = extract val n
1234  // newv = insert newv, x, i
1235  llvm::VectorType *RTy = llvm::VectorType::get(LTy->getElementType(),
1236  MTy->getNumElements());
1237  Value* NewV = llvm::UndefValue::get(RTy);
1238  for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) {
1239  Value *IIndx = llvm::ConstantInt::get(CGF.SizeTy, i);
1240  Value *Indx = Builder.CreateExtractElement(Mask, IIndx, "shuf_idx");
1241 
1242  Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt");
1243  NewV = Builder.CreateInsertElement(NewV, VExt, IIndx, "shuf_ins");
1244  }
1245  return NewV;
1246  }
1247 
1248  Value* V1 = CGF.EmitScalarExpr(E->getExpr(0));
1249  Value* V2 = CGF.EmitScalarExpr(E->getExpr(1));
1250 
1252  for (unsigned i = 2; i < E->getNumSubExprs(); ++i) {
1253  llvm::APSInt Idx = E->getShuffleMaskIdx(CGF.getContext(), i-2);
1254  // Check for -1 and output it as undef in the IR.
1255  if (Idx.isSigned() && Idx.isAllOnesValue())
1256  indices.push_back(llvm::UndefValue::get(CGF.Int32Ty));
1257  else
1258  indices.push_back(Builder.getInt32(Idx.getZExtValue()));
1259  }
1260 
1261  Value *SV = llvm::ConstantVector::get(indices);
1262  return Builder.CreateShuffleVector(V1, V2, SV, "shuffle");
1263 }
1264 
1265 Value *ScalarExprEmitter::VisitConvertVectorExpr(ConvertVectorExpr *E) {
1266  QualType SrcType = E->getSrcExpr()->getType(),
1267  DstType = E->getType();
1268 
1269  Value *Src = CGF.EmitScalarExpr(E->getSrcExpr());
1270 
1271  SrcType = CGF.getContext().getCanonicalType(SrcType);
1272  DstType = CGF.getContext().getCanonicalType(DstType);
1273  if (SrcType == DstType) return Src;
1274 
1275  assert(SrcType->isVectorType() &&
1276  "ConvertVector source type must be a vector");
1277  assert(DstType->isVectorType() &&
1278  "ConvertVector destination type must be a vector");
1279 
1280  llvm::Type *SrcTy = Src->getType();
1281  llvm::Type *DstTy = ConvertType(DstType);
1282 
1283  // Ignore conversions like int -> uint.
1284  if (SrcTy == DstTy)
1285  return Src;
1286 
1287  QualType SrcEltType = SrcType->getAs<VectorType>()->getElementType(),
1288  DstEltType = DstType->getAs<VectorType>()->getElementType();
1289 
1290  assert(SrcTy->isVectorTy() &&
1291  "ConvertVector source IR type must be a vector");
1292  assert(DstTy->isVectorTy() &&
1293  "ConvertVector destination IR type must be a vector");
1294 
1295  llvm::Type *SrcEltTy = SrcTy->getVectorElementType(),
1296  *DstEltTy = DstTy->getVectorElementType();
1297 
1298  if (DstEltType->isBooleanType()) {
1299  assert((SrcEltTy->isFloatingPointTy() ||
1300  isa<llvm::IntegerType>(SrcEltTy)) && "Unknown boolean conversion");
1301 
1302  llvm::Value *Zero = llvm::Constant::getNullValue(SrcTy);
1303  if (SrcEltTy->isFloatingPointTy()) {
1304  return Builder.CreateFCmpUNE(Src, Zero, "tobool");
1305  } else {
1306  return Builder.CreateICmpNE(Src, Zero, "tobool");
1307  }
1308  }
1309 
1310  // We have the arithmetic types: real int/float.
1311  Value *Res = nullptr;
1312 
1313  if (isa<llvm::IntegerType>(SrcEltTy)) {
1314  bool InputSigned = SrcEltType->isSignedIntegerOrEnumerationType();
1315  if (isa<llvm::IntegerType>(DstEltTy))
1316  Res = Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
1317  else if (InputSigned)
1318  Res = Builder.CreateSIToFP(Src, DstTy, "conv");
1319  else
1320  Res = Builder.CreateUIToFP(Src, DstTy, "conv");
1321  } else if (isa<llvm::IntegerType>(DstEltTy)) {
1322  assert(SrcEltTy->isFloatingPointTy() && "Unknown real conversion");
1323  if (DstEltType->isSignedIntegerOrEnumerationType())
1324  Res = Builder.CreateFPToSI(Src, DstTy, "conv");
1325  else
1326  Res = Builder.CreateFPToUI(Src, DstTy, "conv");
1327  } else {
1328  assert(SrcEltTy->isFloatingPointTy() && DstEltTy->isFloatingPointTy() &&
1329  "Unknown real conversion");
1330  if (DstEltTy->getTypeID() < SrcEltTy->getTypeID())
1331  Res = Builder.CreateFPTrunc(Src, DstTy, "conv");
1332  else
1333  Res = Builder.CreateFPExt(Src, DstTy, "conv");
1334  }
1335 
1336  return Res;
1337 }
1338 
1339 Value *ScalarExprEmitter::VisitMemberExpr(MemberExpr *E) {
1340  if (CodeGenFunction::ConstantEmission Constant = CGF.tryEmitAsConstant(E)) {
1341  CGF.EmitIgnoredExpr(E->getBase());
1342  return emitConstant(Constant, E);
1343  } else {
1344  llvm::APSInt Value;
1345  if (E->EvaluateAsInt(Value, CGF.getContext(), Expr::SE_AllowSideEffects)) {
1346  CGF.EmitIgnoredExpr(E->getBase());
1347  return Builder.getInt(Value);
1348  }
1349  }
1350 
1351  return EmitLoadOfLValue(E);
1352 }
1353 
1354 Value *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
1355  TestAndClearIgnoreResultAssign();
1356 
1357  // Emit subscript expressions in rvalue context's. For most cases, this just
1358  // loads the lvalue formed by the subscript expr. However, we have to be
1359  // careful, because the base of a vector subscript is occasionally an rvalue,
1360  // so we can't get it as an lvalue.
1361  if (!E->getBase()->getType()->isVectorType())
1362  return EmitLoadOfLValue(E);
1363 
1364  // Handle the vector case. The base must be a vector, the index must be an
1365  // integer value.
1366  Value *Base = Visit(E->getBase());
1367  Value *Idx = Visit(E->getIdx());
1368  QualType IdxTy = E->getIdx()->getType();
1369 
1370  if (CGF.SanOpts.has(SanitizerKind::ArrayBounds))
1371  CGF.EmitBoundsCheck(E, E->getBase(), Idx, IdxTy, /*Accessed*/true);
1372 
1373  return Builder.CreateExtractElement(Base, Idx, "vecext");
1374 }
1375 
1376 static llvm::Constant *getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx,
1377  unsigned Off, llvm::Type *I32Ty) {
1378  int MV = SVI->getMaskValue(Idx);
1379  if (MV == -1)
1380  return llvm::UndefValue::get(I32Ty);
1381  return llvm::ConstantInt::get(I32Ty, Off+MV);
1382 }
1383 
1384 static llvm::Constant *getAsInt32(llvm::ConstantInt *C, llvm::Type *I32Ty) {
1385  if (C->getBitWidth() != 32) {
1386  assert(llvm::ConstantInt::isValueValidForType(I32Ty,
1387  C->getZExtValue()) &&
1388  "Index operand too large for shufflevector mask!");
1389  return llvm::ConstantInt::get(I32Ty, C->getZExtValue());
1390  }
1391  return C;
1392 }
1393 
1394 Value *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) {
1395  bool Ignore = TestAndClearIgnoreResultAssign();
1396  (void)Ignore;
1397  assert (Ignore == false && "init list ignored");
1398  unsigned NumInitElements = E->getNumInits();
1399 
1400  if (E->hadArrayRangeDesignator())
1401  CGF.ErrorUnsupported(E, "GNU array range designator extension");
1402 
1403  llvm::VectorType *VType =
1404  dyn_cast<llvm::VectorType>(ConvertType(E->getType()));
1405 
1406  if (!VType) {
1407  if (NumInitElements == 0) {
1408  // C++11 value-initialization for the scalar.
1409  return EmitNullValue(E->getType());
1410  }
1411  // We have a scalar in braces. Just use the first element.
1412  return Visit(E->getInit(0));
1413  }
1414 
1415  unsigned ResElts = VType->getNumElements();
1416 
1417  // Loop over initializers collecting the Value for each, and remembering
1418  // whether the source was swizzle (ExtVectorElementExpr). This will allow
1419  // us to fold the shuffle for the swizzle into the shuffle for the vector
1420  // initializer, since LLVM optimizers generally do not want to touch
1421  // shuffles.
1422  unsigned CurIdx = 0;
1423  bool VIsUndefShuffle = false;
1424  llvm::Value *V = llvm::UndefValue::get(VType);
1425  for (unsigned i = 0; i != NumInitElements; ++i) {
1426  Expr *IE = E->getInit(i);
1427  Value *Init = Visit(IE);
1429 
1430  llvm::VectorType *VVT = dyn_cast<llvm::VectorType>(Init->getType());
1431 
1432  // Handle scalar elements. If the scalar initializer is actually one
1433  // element of a different vector of the same width, use shuffle instead of
1434  // extract+insert.
1435  if (!VVT) {
1436  if (isa<ExtVectorElementExpr>(IE)) {
1437  llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init);
1438 
1439  if (EI->getVectorOperandType()->getNumElements() == ResElts) {
1440  llvm::ConstantInt *C = cast<llvm::ConstantInt>(EI->getIndexOperand());
1441  Value *LHS = nullptr, *RHS = nullptr;
1442  if (CurIdx == 0) {
1443  // insert into undef -> shuffle (src, undef)
1444  // shufflemask must use an i32
1445  Args.push_back(getAsInt32(C, CGF.Int32Ty));
1446  Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1447 
1448  LHS = EI->getVectorOperand();
1449  RHS = V;
1450  VIsUndefShuffle = true;
1451  } else if (VIsUndefShuffle) {
1452  // insert into undefshuffle && size match -> shuffle (v, src)
1453  llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V);
1454  for (unsigned j = 0; j != CurIdx; ++j)
1455  Args.push_back(getMaskElt(SVV, j, 0, CGF.Int32Ty));
1456  Args.push_back(Builder.getInt32(ResElts + C->getZExtValue()));
1457  Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1458 
1459  LHS = cast<llvm::ShuffleVectorInst>(V)->getOperand(0);
1460  RHS = EI->getVectorOperand();
1461  VIsUndefShuffle = false;
1462  }
1463  if (!Args.empty()) {
1464  llvm::Constant *Mask = llvm::ConstantVector::get(Args);
1465  V = Builder.CreateShuffleVector(LHS, RHS, Mask);
1466  ++CurIdx;
1467  continue;
1468  }
1469  }
1470  }
1471  V = Builder.CreateInsertElement(V, Init, Builder.getInt32(CurIdx),
1472  "vecinit");
1473  VIsUndefShuffle = false;
1474  ++CurIdx;
1475  continue;
1476  }
1477 
1478  unsigned InitElts = VVT->getNumElements();
1479 
1480  // If the initializer is an ExtVecEltExpr (a swizzle), and the swizzle's
1481  // input is the same width as the vector being constructed, generate an
1482  // optimized shuffle of the swizzle input into the result.
1483  unsigned Offset = (CurIdx == 0) ? 0 : ResElts;
1484  if (isa<ExtVectorElementExpr>(IE)) {
1485  llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init);
1486  Value *SVOp = SVI->getOperand(0);
1487  llvm::VectorType *OpTy = cast<llvm::VectorType>(SVOp->getType());
1488 
1489  if (OpTy->getNumElements() == ResElts) {
1490  for (unsigned j = 0; j != CurIdx; ++j) {
1491  // If the current vector initializer is a shuffle with undef, merge
1492  // this shuffle directly into it.
1493  if (VIsUndefShuffle) {
1494  Args.push_back(getMaskElt(cast<llvm::ShuffleVectorInst>(V), j, 0,
1495  CGF.Int32Ty));
1496  } else {
1497  Args.push_back(Builder.getInt32(j));
1498  }
1499  }
1500  for (unsigned j = 0, je = InitElts; j != je; ++j)
1501  Args.push_back(getMaskElt(SVI, j, Offset, CGF.Int32Ty));
1502  Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1503 
1504  if (VIsUndefShuffle)
1505  V = cast<llvm::ShuffleVectorInst>(V)->getOperand(0);
1506 
1507  Init = SVOp;
1508  }
1509  }
1510 
1511  // Extend init to result vector length, and then shuffle its contribution
1512  // to the vector initializer into V.
1513  if (Args.empty()) {
1514  for (unsigned j = 0; j != InitElts; ++j)
1515  Args.push_back(Builder.getInt32(j));
1516  Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1517  llvm::Constant *Mask = llvm::ConstantVector::get(Args);
1518  Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT),
1519  Mask, "vext");
1520 
1521  Args.clear();
1522  for (unsigned j = 0; j != CurIdx; ++j)
1523  Args.push_back(Builder.getInt32(j));
1524  for (unsigned j = 0; j != InitElts; ++j)
1525  Args.push_back(Builder.getInt32(j+Offset));
1526  Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1527  }
1528 
1529  // If V is undef, make sure it ends up on the RHS of the shuffle to aid
1530  // merging subsequent shuffles into this one.
1531  if (CurIdx == 0)
1532  std::swap(V, Init);
1533  llvm::Constant *Mask = llvm::ConstantVector::get(Args);
1534  V = Builder.CreateShuffleVector(V, Init, Mask, "vecinit");
1535  VIsUndefShuffle = isa<llvm::UndefValue>(Init);
1536  CurIdx += InitElts;
1537  }
1538 
1539  // FIXME: evaluate codegen vs. shuffling against constant null vector.
1540  // Emit remaining default initializers.
1541  llvm::Type *EltTy = VType->getElementType();
1542 
1543  // Emit remaining default initializers
1544  for (/* Do not initialize i*/; CurIdx < ResElts; ++CurIdx) {
1545  Value *Idx = Builder.getInt32(CurIdx);
1546  llvm::Value *Init = llvm::Constant::getNullValue(EltTy);
1547  V = Builder.CreateInsertElement(V, Init, Idx, "vecinit");
1548  }
1549  return V;
1550 }
1551 
1553  const Expr *E = CE->getSubExpr();
1554 
1555  if (CE->getCastKind() == CK_UncheckedDerivedToBase)
1556  return false;
1557 
1558  if (isa<CXXThisExpr>(E->IgnoreParens())) {
1559  // We always assume that 'this' is never null.
1560  return false;
1561  }
1562 
1563  if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(CE)) {
1564  // And that glvalue casts are never null.
1565  if (ICE->getValueKind() != VK_RValue)
1566  return false;
1567  }
1568 
1569  return true;
1570 }
1571 
1572 // VisitCastExpr - Emit code for an explicit or implicit cast. Implicit casts
1573 // have to handle a more broad range of conversions than explicit casts, as they
1574 // handle things like function to ptr-to-function decay etc.
1575 Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
1576  Expr *E = CE->getSubExpr();
1577  QualType DestTy = CE->getType();
1578  CastKind Kind = CE->getCastKind();
1579 
1580  // These cases are generally not written to ignore the result of
1581  // evaluating their sub-expressions, so we clear this now.
1582  bool Ignored = TestAndClearIgnoreResultAssign();
1583 
1584  // Since almost all cast kinds apply to scalars, this switch doesn't have
1585  // a default case, so the compiler will warn on a missing case. The cases
1586  // are in the same order as in the CastKind enum.
1587  switch (Kind) {
1588  case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!");
1589  case CK_BuiltinFnToFnPtr:
1590  llvm_unreachable("builtin functions are handled elsewhere");
1591 
1592  case CK_LValueBitCast:
1593  case CK_ObjCObjectLValueCast: {
1594  Address Addr = EmitLValue(E).getAddress();
1595  Addr = Builder.CreateElementBitCast(Addr, CGF.ConvertTypeForMem(DestTy));
1596  LValue LV = CGF.MakeAddrLValue(Addr, DestTy);
1597  return EmitLoadOfLValue(LV, CE->getExprLoc());
1598  }
1599 
1600  case CK_CPointerToObjCPointerCast:
1601  case CK_BlockPointerToObjCPointerCast:
1602  case CK_AnyPointerToBlockPointerCast:
1603  case CK_BitCast: {
1604  Value *Src = Visit(const_cast<Expr*>(E));
1605  llvm::Type *SrcTy = Src->getType();
1606  llvm::Type *DstTy = ConvertType(DestTy);
1607  if (SrcTy->isPtrOrPtrVectorTy() && DstTy->isPtrOrPtrVectorTy() &&
1608  SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace()) {
1609  llvm_unreachable("wrong cast for pointers in different address spaces"
1610  "(must be an address space cast)!");
1611  }
1612 
1613  if (CGF.SanOpts.has(SanitizerKind::CFIUnrelatedCast)) {
1614  if (auto PT = DestTy->getAs<PointerType>())
1615  CGF.EmitVTablePtrCheckForCast(PT->getPointeeType(), Src,
1616  /*MayBeNull=*/true,
1618  CE->getLocStart());
1619  }
1620 
1621  return Builder.CreateBitCast(Src, DstTy);
1622  }
1623  case CK_AddressSpaceConversion: {
1624  Expr::EvalResult Result;
1625  if (E->EvaluateAsRValue(Result, CGF.getContext()) &&
1626  Result.Val.isNullPointer()) {
1627  // If E has side effect, it is emitted even if its final result is a
1628  // null pointer. In that case, a DCE pass should be able to
1629  // eliminate the useless instructions emitted during translating E.
1630  if (Result.HasSideEffects)
1631  Visit(E);
1632  return CGF.CGM.getNullPointer(cast<llvm::PointerType>(
1633  ConvertType(DestTy)), DestTy);
1634  }
1635  // Since target may map different address spaces in AST to the same address
1636  // space, an address space conversion may end up as a bitcast.
1638  CGF, Visit(E), E->getType()->getPointeeType().getAddressSpace(),
1639  DestTy->getPointeeType().getAddressSpace(), ConvertType(DestTy));
1640  }
1641  case CK_AtomicToNonAtomic:
1642  case CK_NonAtomicToAtomic:
1643  case CK_NoOp:
1644  case CK_UserDefinedConversion:
1645  return Visit(const_cast<Expr*>(E));
1646 
1647  case CK_BaseToDerived: {
1648  const CXXRecordDecl *DerivedClassDecl = DestTy->getPointeeCXXRecordDecl();
1649  assert(DerivedClassDecl && "BaseToDerived arg isn't a C++ object pointer!");
1650 
1651  Address Base = CGF.EmitPointerWithAlignment(E);
1652  Address Derived =
1653  CGF.GetAddressOfDerivedClass(Base, DerivedClassDecl,
1654  CE->path_begin(), CE->path_end(),
1656 
1657  // C++11 [expr.static.cast]p11: Behavior is undefined if a downcast is
1658  // performed and the object is not of the derived type.
1659  if (CGF.sanitizePerformTypeCheck())
1661  Derived.getPointer(), DestTy->getPointeeType());
1662 
1663  if (CGF.SanOpts.has(SanitizerKind::CFIDerivedCast))
1665  Derived.getPointer(),
1666  /*MayBeNull=*/true,
1668  CE->getLocStart());
1669 
1670  return Derived.getPointer();
1671  }
1672  case CK_UncheckedDerivedToBase:
1673  case CK_DerivedToBase: {
1674  // The EmitPointerWithAlignment path does this fine; just discard
1675  // the alignment.
1676  return CGF.EmitPointerWithAlignment(CE).getPointer();
1677  }
1678 
1679  case CK_Dynamic: {
1680  Address V = CGF.EmitPointerWithAlignment(E);
1681  const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(CE);
1682  return CGF.EmitDynamicCast(V, DCE);
1683  }
1684 
1685  case CK_ArrayToPointerDecay:
1686  return CGF.EmitArrayToPointerDecay(E).getPointer();
1687  case CK_FunctionToPointerDecay:
1688  return EmitLValue(E).getPointer();
1689 
1690  case CK_NullToPointer:
1691  if (MustVisitNullValue(E))
1692  (void) Visit(E);
1693 
1694  return CGF.CGM.getNullPointer(cast<llvm::PointerType>(ConvertType(DestTy)),
1695  DestTy);
1696 
1697  case CK_NullToMemberPointer: {
1698  if (MustVisitNullValue(E))
1699  (void) Visit(E);
1700 
1701  const MemberPointerType *MPT = CE->getType()->getAs<MemberPointerType>();
1702  return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT);
1703  }
1704 
1705  case CK_ReinterpretMemberPointer:
1706  case CK_BaseToDerivedMemberPointer:
1707  case CK_DerivedToBaseMemberPointer: {
1708  Value *Src = Visit(E);
1709 
1710  // Note that the AST doesn't distinguish between checked and
1711  // unchecked member pointer conversions, so we always have to
1712  // implement checked conversions here. This is inefficient when
1713  // actual control flow may be required in order to perform the
1714  // check, which it is for data member pointers (but not member
1715  // function pointers on Itanium and ARM).
1716  return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src);
1717  }
1718 
1719  case CK_ARCProduceObject:
1720  return CGF.EmitARCRetainScalarExpr(E);
1721  case CK_ARCConsumeObject:
1722  return CGF.EmitObjCConsumeObject(E->getType(), Visit(E));
1723  case CK_ARCReclaimReturnedObject:
1724  return CGF.EmitARCReclaimReturnedObject(E, /*allowUnsafe*/ Ignored);
1725  case CK_ARCExtendBlockObject:
1726  return CGF.EmitARCExtendBlockObject(E);
1727 
1728  case CK_CopyAndAutoreleaseBlockObject:
1729  return CGF.EmitBlockCopyAndAutorelease(Visit(E), E->getType());
1730 
1731  case CK_FloatingRealToComplex:
1732  case CK_FloatingComplexCast:
1733  case CK_IntegralRealToComplex:
1734  case CK_IntegralComplexCast:
1735  case CK_IntegralComplexToFloatingComplex:
1736  case CK_FloatingComplexToIntegralComplex:
1737  case CK_ConstructorConversion:
1738  case CK_ToUnion:
1739  llvm_unreachable("scalar cast to non-scalar value");
1740 
1741  case CK_LValueToRValue:
1742  assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy));
1743  assert(E->isGLValue() && "lvalue-to-rvalue applied to r-value!");
1744  return Visit(const_cast<Expr*>(E));
1745 
1746  case CK_IntegralToPointer: {
1747  Value *Src = Visit(const_cast<Expr*>(E));
1748 
1749  // First, convert to the correct width so that we control the kind of
1750  // extension.
1751  auto DestLLVMTy = ConvertType(DestTy);
1752  llvm::Type *MiddleTy = CGF.CGM.getDataLayout().getIntPtrType(DestLLVMTy);
1753  bool InputSigned = E->getType()->isSignedIntegerOrEnumerationType();
1754  llvm::Value* IntResult =
1755  Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv");
1756 
1757  return Builder.CreateIntToPtr(IntResult, DestLLVMTy);
1758  }
1759  case CK_PointerToIntegral:
1760  assert(!DestTy->isBooleanType() && "bool should use PointerToBool");
1761  return Builder.CreatePtrToInt(Visit(E), ConvertType(DestTy));
1762 
1763  case CK_ToVoid: {
1764  CGF.EmitIgnoredExpr(E);
1765  return nullptr;
1766  }
1767  case CK_VectorSplat: {
1768  llvm::Type *DstTy = ConvertType(DestTy);
1769  Value *Elt = Visit(const_cast<Expr*>(E));
1770  // Splat the element across to all elements
1771  unsigned NumElements = DstTy->getVectorNumElements();
1772  return Builder.CreateVectorSplat(NumElements, Elt, "splat");
1773  }
1774 
1775  case CK_IntegralCast:
1776  case CK_IntegralToFloating:
1777  case CK_FloatingToIntegral:
1778  case CK_FloatingCast:
1779  return EmitScalarConversion(Visit(E), E->getType(), DestTy,
1780  CE->getExprLoc());
1781  case CK_BooleanToSignedIntegral:
1782  return EmitScalarConversion(Visit(E), E->getType(), DestTy,
1783  CE->getExprLoc(),
1784  /*TreatBooleanAsSigned=*/true);
1785  case CK_IntegralToBoolean:
1786  return EmitIntToBoolConversion(Visit(E));
1787  case CK_PointerToBoolean:
1788  return EmitPointerToBoolConversion(Visit(E), E->getType());
1789  case CK_FloatingToBoolean:
1790  return EmitFloatToBoolConversion(Visit(E));
1791  case CK_MemberPointerToBoolean: {
1792  llvm::Value *MemPtr = Visit(E);
1793  const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>();
1794  return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT);
1795  }
1796 
1797  case CK_FloatingComplexToReal:
1798  case CK_IntegralComplexToReal:
1799  return CGF.EmitComplexExpr(E, false, true).first;
1800 
1801  case CK_FloatingComplexToBoolean:
1802  case CK_IntegralComplexToBoolean: {
1804 
1805  // TODO: kill this function off, inline appropriate case here
1806  return EmitComplexToScalarConversion(V, E->getType(), DestTy,
1807  CE->getExprLoc());
1808  }
1809 
1810  case CK_ZeroToOCLEvent: {
1811  assert(DestTy->isEventT() && "CK_ZeroToOCLEvent cast on non-event type");
1812  return llvm::Constant::getNullValue(ConvertType(DestTy));
1813  }
1814 
1815  case CK_ZeroToOCLQueue: {
1816  assert(DestTy->isQueueT() && "CK_ZeroToOCLQueue cast on non queue_t type");
1817  return llvm::Constant::getNullValue(ConvertType(DestTy));
1818  }
1819 
1820  case CK_IntToOCLSampler:
1821  return CGF.CGM.createOpenCLIntToSamplerConversion(E, CGF);
1822 
1823  } // end of switch
1824 
1825  llvm_unreachable("unknown scalar cast");
1826 }
1827 
1828 Value *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) {
1830  Address RetAlloca = CGF.EmitCompoundStmt(*E->getSubStmt(),
1831  !E->getType()->isVoidType());
1832  if (!RetAlloca.isValid())
1833  return nullptr;
1834  return CGF.EmitLoadOfScalar(CGF.MakeAddrLValue(RetAlloca, E->getType()),
1835  E->getExprLoc());
1836 }
1837 
1838 Value *ScalarExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) {
1839  CGF.enterFullExpression(E);
1841  Value *V = Visit(E->getSubExpr());
1842  // Defend against dominance problems caused by jumps out of expression
1843  // evaluation through the shared cleanup block.
1844  Scope.ForceCleanup({&V});
1845  return V;
1846 }
1847 
1848 //===----------------------------------------------------------------------===//
1849 // Unary Operators
1850 //===----------------------------------------------------------------------===//
1851 
1852 static BinOpInfo createBinOpInfoFromIncDec(const UnaryOperator *E,
1853  llvm::Value *InVal, bool IsInc) {
1854  BinOpInfo BinOp;
1855  BinOp.LHS = InVal;
1856  BinOp.RHS = llvm::ConstantInt::get(InVal->getType(), 1, false);
1857  BinOp.Ty = E->getType();
1858  BinOp.Opcode = IsInc ? BO_Add : BO_Sub;
1859  // FIXME: once UnaryOperator carries FPFeatures, copy it here.
1860  BinOp.E = E;
1861  return BinOp;
1862 }
1863 
1864 llvm::Value *ScalarExprEmitter::EmitIncDecConsiderOverflowBehavior(
1865  const UnaryOperator *E, llvm::Value *InVal, bool IsInc) {
1866  llvm::Value *Amount =
1867  llvm::ConstantInt::get(InVal->getType(), IsInc ? 1 : -1, true);
1868  StringRef Name = IsInc ? "inc" : "dec";
1869  switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
1871  return Builder.CreateAdd(InVal, Amount, Name);
1873  if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
1874  return Builder.CreateNSWAdd(InVal, Amount, Name);
1875  // Fall through.
1877  if (!E->canOverflow())
1878  return Builder.CreateNSWAdd(InVal, Amount, Name);
1879  return EmitOverflowCheckedBinOp(createBinOpInfoFromIncDec(E, InVal, IsInc));
1880  }
1881  llvm_unreachable("Unknown SignedOverflowBehaviorTy");
1882 }
1883 
1884 llvm::Value *
1885 ScalarExprEmitter::EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
1886  bool isInc, bool isPre) {
1887 
1888  QualType type = E->getSubExpr()->getType();
1889  llvm::PHINode *atomicPHI = nullptr;
1890  llvm::Value *value;
1891  llvm::Value *input;
1892 
1893  int amount = (isInc ? 1 : -1);
1894  bool isSubtraction = !isInc;
1895 
1896  if (const AtomicType *atomicTy = type->getAs<AtomicType>()) {
1897  type = atomicTy->getValueType();
1898  if (isInc && type->isBooleanType()) {
1899  llvm::Value *True = CGF.EmitToMemory(Builder.getTrue(), type);
1900  if (isPre) {
1901  Builder.CreateStore(True, LV.getAddress(), LV.isVolatileQualified())
1902  ->setAtomic(llvm::AtomicOrdering::SequentiallyConsistent);
1903  return Builder.getTrue();
1904  }
1905  // For atomic bool increment, we just store true and return it for
1906  // preincrement, do an atomic swap with true for postincrement
1907  return Builder.CreateAtomicRMW(
1908  llvm::AtomicRMWInst::Xchg, LV.getPointer(), True,
1909  llvm::AtomicOrdering::SequentiallyConsistent);
1910  }
1911  // Special case for atomic increment / decrement on integers, emit
1912  // atomicrmw instructions. We skip this if we want to be doing overflow
1913  // checking, and fall into the slow path with the atomic cmpxchg loop.
1914  if (!type->isBooleanType() && type->isIntegerType() &&
1915  !(type->isUnsignedIntegerType() &&
1916  CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) &&
1917  CGF.getLangOpts().getSignedOverflowBehavior() !=
1919  llvm::AtomicRMWInst::BinOp aop = isInc ? llvm::AtomicRMWInst::Add :
1920  llvm::AtomicRMWInst::Sub;
1921  llvm::Instruction::BinaryOps op = isInc ? llvm::Instruction::Add :
1922  llvm::Instruction::Sub;
1923  llvm::Value *amt = CGF.EmitToMemory(
1924  llvm::ConstantInt::get(ConvertType(type), 1, true), type);
1925  llvm::Value *old = Builder.CreateAtomicRMW(aop,
1926  LV.getPointer(), amt, llvm::AtomicOrdering::SequentiallyConsistent);
1927  return isPre ? Builder.CreateBinOp(op, old, amt) : old;
1928  }
1929  value = EmitLoadOfLValue(LV, E->getExprLoc());
1930  input = value;
1931  // For every other atomic operation, we need to emit a load-op-cmpxchg loop
1932  llvm::BasicBlock *startBB = Builder.GetInsertBlock();
1933  llvm::BasicBlock *opBB = CGF.createBasicBlock("atomic_op", CGF.CurFn);
1934  value = CGF.EmitToMemory(value, type);
1935  Builder.CreateBr(opBB);
1936  Builder.SetInsertPoint(opBB);
1937  atomicPHI = Builder.CreatePHI(value->getType(), 2);
1938  atomicPHI->addIncoming(value, startBB);
1939  value = atomicPHI;
1940  } else {
1941  value = EmitLoadOfLValue(LV, E->getExprLoc());
1942  input = value;
1943  }
1944 
1945  // Special case of integer increment that we have to check first: bool++.
1946  // Due to promotion rules, we get:
1947  // bool++ -> bool = bool + 1
1948  // -> bool = (int)bool + 1
1949  // -> bool = ((int)bool + 1 != 0)
1950  // An interesting aspect of this is that increment is always true.
1951  // Decrement does not have this property.
1952  if (isInc && type->isBooleanType()) {
1953  value = Builder.getTrue();
1954 
1955  // Most common case by far: integer increment.
1956  } else if (type->isIntegerType()) {
1957  // Note that signed integer inc/dec with width less than int can't
1958  // overflow because of promotion rules; we're just eliding a few steps here.
1959  if (E->canOverflow() && type->isSignedIntegerOrEnumerationType()) {
1960  value = EmitIncDecConsiderOverflowBehavior(E, value, isInc);
1961  } else if (E->canOverflow() && type->isUnsignedIntegerType() &&
1962  CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) {
1963  value =
1964  EmitOverflowCheckedBinOp(createBinOpInfoFromIncDec(E, value, isInc));
1965  } else {
1966  llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount, true);
1967  value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
1968  }
1969 
1970  // Next most common: pointer increment.
1971  } else if (const PointerType *ptr = type->getAs<PointerType>()) {
1972  QualType type = ptr->getPointeeType();
1973 
1974  // VLA types don't have constant size.
1975  if (const VariableArrayType *vla
1976  = CGF.getContext().getAsVariableArrayType(type)) {
1977  llvm::Value *numElts = CGF.getVLASize(vla).NumElts;
1978  if (!isInc) numElts = Builder.CreateNSWNeg(numElts, "vla.negsize");
1980  value = Builder.CreateGEP(value, numElts, "vla.inc");
1981  else
1982  value = CGF.EmitCheckedInBoundsGEP(
1983  value, numElts, /*SignedIndices=*/false, isSubtraction,
1984  E->getExprLoc(), "vla.inc");
1985 
1986  // Arithmetic on function pointers (!) is just +-1.
1987  } else if (type->isFunctionType()) {
1988  llvm::Value *amt = Builder.getInt32(amount);
1989 
1990  value = CGF.EmitCastToVoidPtr(value);
1992  value = Builder.CreateGEP(value, amt, "incdec.funcptr");
1993  else
1994  value = CGF.EmitCheckedInBoundsGEP(value, amt, /*SignedIndices=*/false,
1995  isSubtraction, E->getExprLoc(),
1996  "incdec.funcptr");
1997  value = Builder.CreateBitCast(value, input->getType());
1998 
1999  // For everything else, we can just do a simple increment.
2000  } else {
2001  llvm::Value *amt = Builder.getInt32(amount);
2003  value = Builder.CreateGEP(value, amt, "incdec.ptr");
2004  else
2005  value = CGF.EmitCheckedInBoundsGEP(value, amt, /*SignedIndices=*/false,
2006  isSubtraction, E->getExprLoc(),
2007  "incdec.ptr");
2008  }
2009 
2010  // Vector increment/decrement.
2011  } else if (type->isVectorType()) {
2012  if (type->hasIntegerRepresentation()) {
2013  llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount);
2014 
2015  value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
2016  } else {
2017  value = Builder.CreateFAdd(
2018  value,
2019  llvm::ConstantFP::get(value->getType(), amount),
2020  isInc ? "inc" : "dec");
2021  }
2022 
2023  // Floating point.
2024  } else if (type->isRealFloatingType()) {
2025  // Add the inc/dec to the real part.
2026  llvm::Value *amt;
2027 
2028  if (type->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
2029  // Another special case: half FP increment should be done via float
2031  value = Builder.CreateCall(
2032  CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16,
2033  CGF.CGM.FloatTy),
2034  input, "incdec.conv");
2035  } else {
2036  value = Builder.CreateFPExt(input, CGF.CGM.FloatTy, "incdec.conv");
2037  }
2038  }
2039 
2040  if (value->getType()->isFloatTy())
2041  amt = llvm::ConstantFP::get(VMContext,
2042  llvm::APFloat(static_cast<float>(amount)));
2043  else if (value->getType()->isDoubleTy())
2044  amt = llvm::ConstantFP::get(VMContext,
2045  llvm::APFloat(static_cast<double>(amount)));
2046  else {
2047  // Remaining types are Half, LongDouble or __float128. Convert from float.
2048  llvm::APFloat F(static_cast<float>(amount));
2049  bool ignored;
2050  const llvm::fltSemantics *FS;
2051  // Don't use getFloatTypeSemantics because Half isn't
2052  // necessarily represented using the "half" LLVM type.
2053  if (value->getType()->isFP128Ty())
2054  FS = &CGF.getTarget().getFloat128Format();
2055  else if (value->getType()->isHalfTy())
2056  FS = &CGF.getTarget().getHalfFormat();
2057  else
2058  FS = &CGF.getTarget().getLongDoubleFormat();
2059  F.convert(*FS, llvm::APFloat::rmTowardZero, &ignored);
2060  amt = llvm::ConstantFP::get(VMContext, F);
2061  }
2062  value = Builder.CreateFAdd(value, amt, isInc ? "inc" : "dec");
2063 
2064  if (type->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
2066  value = Builder.CreateCall(
2067  CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16,
2068  CGF.CGM.FloatTy),
2069  value, "incdec.conv");
2070  } else {
2071  value = Builder.CreateFPTrunc(value, input->getType(), "incdec.conv");
2072  }
2073  }
2074 
2075  // Objective-C pointer types.
2076  } else {
2077  const ObjCObjectPointerType *OPT = type->castAs<ObjCObjectPointerType>();
2078  value = CGF.EmitCastToVoidPtr(value);
2079 
2081  if (!isInc) size = -size;
2082  llvm::Value *sizeValue =
2083  llvm::ConstantInt::get(CGF.SizeTy, size.getQuantity());
2084 
2086  value = Builder.CreateGEP(value, sizeValue, "incdec.objptr");
2087  else
2088  value = CGF.EmitCheckedInBoundsGEP(value, sizeValue,
2089  /*SignedIndices=*/false, isSubtraction,
2090  E->getExprLoc(), "incdec.objptr");
2091  value = Builder.CreateBitCast(value, input->getType());
2092  }
2093 
2094  if (atomicPHI) {
2095  llvm::BasicBlock *opBB = Builder.GetInsertBlock();
2096  llvm::BasicBlock *contBB = CGF.createBasicBlock("atomic_cont", CGF.CurFn);
2097  auto Pair = CGF.EmitAtomicCompareExchange(
2098  LV, RValue::get(atomicPHI), RValue::get(value), E->getExprLoc());
2099  llvm::Value *old = CGF.EmitToMemory(Pair.first.getScalarVal(), type);
2100  llvm::Value *success = Pair.second;
2101  atomicPHI->addIncoming(old, opBB);
2102  Builder.CreateCondBr(success, contBB, opBB);
2103  Builder.SetInsertPoint(contBB);
2104  return isPre ? value : input;
2105  }
2106 
2107  // Store the updated result through the lvalue.
2108  if (LV.isBitField())
2109  CGF.EmitStoreThroughBitfieldLValue(RValue::get(value), LV, &value);
2110  else
2111  CGF.EmitStoreThroughLValue(RValue::get(value), LV);
2112 
2113  // If this is a postinc, return the value read from memory, otherwise use the
2114  // updated value.
2115  return isPre ? value : input;
2116 }
2117 
2118 
2119 
2120 Value *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) {
2121  TestAndClearIgnoreResultAssign();
2122  // Emit unary minus with EmitSub so we handle overflow cases etc.
2123  BinOpInfo BinOp;
2124  BinOp.RHS = Visit(E->getSubExpr());
2125 
2126  if (BinOp.RHS->getType()->isFPOrFPVectorTy())
2127  BinOp.LHS = llvm::ConstantFP::getZeroValueForNegation(BinOp.RHS->getType());
2128  else
2129  BinOp.LHS = llvm::Constant::getNullValue(BinOp.RHS->getType());
2130  BinOp.Ty = E->getType();
2131  BinOp.Opcode = BO_Sub;
2132  // FIXME: once UnaryOperator carries FPFeatures, copy it here.
2133  BinOp.E = E;
2134  return EmitSub(BinOp);
2135 }
2136 
2137 Value *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
2138  TestAndClearIgnoreResultAssign();
2139  Value *Op = Visit(E->getSubExpr());
2140  return Builder.CreateNot(Op, "neg");
2141 }
2142 
2143 Value *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) {
2144  // Perform vector logical not on comparison with zero vector.
2145  if (E->getType()->isExtVectorType()) {
2146  Value *Oper = Visit(E->getSubExpr());
2147  Value *Zero = llvm::Constant::getNullValue(Oper->getType());
2148  Value *Result;
2149  if (Oper->getType()->isFPOrFPVectorTy())
2150  Result = Builder.CreateFCmp(llvm::CmpInst::FCMP_OEQ, Oper, Zero, "cmp");
2151  else
2152  Result = Builder.CreateICmp(llvm::CmpInst::ICMP_EQ, Oper, Zero, "cmp");
2153  return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
2154  }
2155 
2156  // Compare operand to zero.
2157  Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr());
2158 
2159  // Invert value.
2160  // TODO: Could dynamically modify easy computations here. For example, if
2161  // the operand is an icmp ne, turn into icmp eq.
2162  BoolVal = Builder.CreateNot(BoolVal, "lnot");
2163 
2164  // ZExt result to the expr type.
2165  return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext");
2166 }
2167 
2168 Value *ScalarExprEmitter::VisitOffsetOfExpr(OffsetOfExpr *E) {
2169  // Try folding the offsetof to a constant.
2170  llvm::APSInt Value;
2171  if (E->EvaluateAsInt(Value, CGF.getContext()))
2172  return Builder.getInt(Value);
2173 
2174  // Loop over the components of the offsetof to compute the value.
2175  unsigned n = E->getNumComponents();
2176  llvm::Type* ResultType = ConvertType(E->getType());
2177  llvm::Value* Result = llvm::Constant::getNullValue(ResultType);
2178  QualType CurrentType = E->getTypeSourceInfo()->getType();
2179  for (unsigned i = 0; i != n; ++i) {
2180  OffsetOfNode ON = E->getComponent(i);
2181  llvm::Value *Offset = nullptr;
2182  switch (ON.getKind()) {
2183  case OffsetOfNode::Array: {
2184  // Compute the index
2185  Expr *IdxExpr = E->getIndexExpr(ON.getArrayExprIndex());
2186  llvm::Value* Idx = CGF.EmitScalarExpr(IdxExpr);
2187  bool IdxSigned = IdxExpr->getType()->isSignedIntegerOrEnumerationType();
2188  Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned, "conv");
2189 
2190  // Save the element type
2191  CurrentType =
2192  CGF.getContext().getAsArrayType(CurrentType)->getElementType();
2193 
2194  // Compute the element size
2195  llvm::Value* ElemSize = llvm::ConstantInt::get(ResultType,
2196  CGF.getContext().getTypeSizeInChars(CurrentType).getQuantity());
2197 
2198  // Multiply out to compute the result
2199  Offset = Builder.CreateMul(Idx, ElemSize);
2200  break;
2201  }
2202 
2203  case OffsetOfNode::Field: {
2204  FieldDecl *MemberDecl = ON.getField();
2205  RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl();
2206  const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD);
2207 
2208  // Compute the index of the field in its parent.
2209  unsigned i = 0;
2210  // FIXME: It would be nice if we didn't have to loop here!
2211  for (RecordDecl::field_iterator Field = RD->field_begin(),
2212  FieldEnd = RD->field_end();
2213  Field != FieldEnd; ++Field, ++i) {
2214  if (*Field == MemberDecl)
2215  break;
2216  }
2217  assert(i < RL.getFieldCount() && "offsetof field in wrong type");
2218 
2219  // Compute the offset to the field
2220  int64_t OffsetInt = RL.getFieldOffset(i) /
2221  CGF.getContext().getCharWidth();
2222  Offset = llvm::ConstantInt::get(ResultType, OffsetInt);
2223 
2224  // Save the element type.
2225  CurrentType = MemberDecl->getType();
2226  break;
2227  }
2228 
2230  llvm_unreachable("dependent __builtin_offsetof");
2231 
2232  case OffsetOfNode::Base: {
2233  if (ON.getBase()->isVirtual()) {
2234  CGF.ErrorUnsupported(E, "virtual base in offsetof");
2235  continue;
2236  }
2237 
2238  RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl();
2239  const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD);
2240 
2241  // Save the element type.
2242  CurrentType = ON.getBase()->getType();
2243 
2244  // Compute the offset to the base.
2245  const RecordType *BaseRT = CurrentType->getAs<RecordType>();
2246  CXXRecordDecl *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl());
2247  CharUnits OffsetInt = RL.getBaseClassOffset(BaseRD);
2248  Offset = llvm::ConstantInt::get(ResultType, OffsetInt.getQuantity());
2249  break;
2250  }
2251  }
2252  Result = Builder.CreateAdd(Result, Offset);
2253  }
2254  return Result;
2255 }
2256 
2257 /// VisitUnaryExprOrTypeTraitExpr - Return the size or alignment of the type of
2258 /// argument of the sizeof expression as an integer.
2259 Value *
2260 ScalarExprEmitter::VisitUnaryExprOrTypeTraitExpr(
2261  const UnaryExprOrTypeTraitExpr *E) {
2262  QualType TypeToSize = E->getTypeOfArgument();
2263  if (E->getKind() == UETT_SizeOf) {
2264  if (const VariableArrayType *VAT =
2265  CGF.getContext().getAsVariableArrayType(TypeToSize)) {
2266  if (E->isArgumentType()) {
2267  // sizeof(type) - make sure to emit the VLA size.
2268  CGF.EmitVariablyModifiedType(TypeToSize);
2269  } else {
2270  // C99 6.5.3.4p2: If the argument is an expression of type
2271  // VLA, it is evaluated.
2272  CGF.EmitIgnoredExpr(E->getArgumentExpr());
2273  }
2274 
2275  auto VlaSize = CGF.getVLASize(VAT);
2276  llvm::Value *size = VlaSize.NumElts;
2277 
2278  // Scale the number of non-VLA elements by the non-VLA element size.
2279  CharUnits eltSize = CGF.getContext().getTypeSizeInChars(VlaSize.Type);
2280  if (!eltSize.isOne())
2281  size = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), size);
2282 
2283  return size;
2284  }
2285  } else if (E->getKind() == UETT_OpenMPRequiredSimdAlign) {
2286  auto Alignment =
2287  CGF.getContext()
2290  .getQuantity();
2291  return llvm::ConstantInt::get(CGF.SizeTy, Alignment);
2292  }
2293 
2294  // If this isn't sizeof(vla), the result must be constant; use the constant
2295  // folding logic so we don't have to duplicate it here.
2296  return Builder.getInt(E->EvaluateKnownConstInt(CGF.getContext()));
2297 }
2298 
2299 Value *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) {
2300  Expr *Op = E->getSubExpr();
2301  if (Op->getType()->isAnyComplexType()) {
2302  // If it's an l-value, load through the appropriate subobject l-value.
2303  // Note that we have to ask E because Op might be an l-value that
2304  // this won't work for, e.g. an Obj-C property.
2305  if (E->isGLValue())
2306  return CGF.EmitLoadOfLValue(CGF.EmitLValue(E),
2307  E->getExprLoc()).getScalarVal();
2308 
2309  // Otherwise, calculate and project.
2310  return CGF.EmitComplexExpr(Op, false, true).first;
2311  }
2312 
2313  return Visit(Op);
2314 }
2315 
2316 Value *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) {
2317  Expr *Op = E->getSubExpr();
2318  if (Op->getType()->isAnyComplexType()) {
2319  // If it's an l-value, load through the appropriate subobject l-value.
2320  // Note that we have to ask E because Op might be an l-value that
2321  // this won't work for, e.g. an Obj-C property.
2322  if (Op->isGLValue())
2323  return CGF.EmitLoadOfLValue(CGF.EmitLValue(E),
2324  E->getExprLoc()).getScalarVal();
2325 
2326  // Otherwise, calculate and project.
2327  return CGF.EmitComplexExpr(Op, true, false).second;
2328  }
2329 
2330  // __imag on a scalar returns zero. Emit the subexpr to ensure side
2331  // effects are evaluated, but not the actual value.
2332  if (Op->isGLValue())
2333  CGF.EmitLValue(Op);
2334  else
2335  CGF.EmitScalarExpr(Op, true);
2336  return llvm::Constant::getNullValue(ConvertType(E->getType()));
2337 }
2338 
2339 //===----------------------------------------------------------------------===//
2340 // Binary Operators
2341 //===----------------------------------------------------------------------===//
2342 
2343 BinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) {
2344  TestAndClearIgnoreResultAssign();
2345  BinOpInfo Result;
2346  Result.LHS = Visit(E->getLHS());
2347  Result.RHS = Visit(E->getRHS());
2348  Result.Ty = E->getType();
2349  Result.Opcode = E->getOpcode();
2350  Result.FPFeatures = E->getFPFeatures();
2351  Result.E = E;
2352  return Result;
2353 }
2354 
2355 LValue ScalarExprEmitter::EmitCompoundAssignLValue(
2356  const CompoundAssignOperator *E,
2357  Value *(ScalarExprEmitter::*Func)(const BinOpInfo &),
2358  Value *&Result) {
2359  QualType LHSTy = E->getLHS()->getType();
2360  BinOpInfo OpInfo;
2361 
2363  return CGF.EmitScalarCompoundAssignWithComplex(E, Result);
2364 
2365  // Emit the RHS first. __block variables need to have the rhs evaluated
2366  // first, plus this should improve codegen a little.
2367  OpInfo.RHS = Visit(E->getRHS());
2368  OpInfo.Ty = E->getComputationResultType();
2369  OpInfo.Opcode = E->getOpcode();
2370  OpInfo.FPFeatures = E->getFPFeatures();
2371  OpInfo.E = E;
2372  // Load/convert the LHS.
2373  LValue LHSLV = EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
2374 
2375  llvm::PHINode *atomicPHI = nullptr;
2376  if (const AtomicType *atomicTy = LHSTy->getAs<AtomicType>()) {
2377  QualType type = atomicTy->getValueType();
2378  if (!type->isBooleanType() && type->isIntegerType() &&
2379  !(type->isUnsignedIntegerType() &&
2380  CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) &&
2381  CGF.getLangOpts().getSignedOverflowBehavior() !=
2383  llvm::AtomicRMWInst::BinOp aop = llvm::AtomicRMWInst::BAD_BINOP;
2384  switch (OpInfo.Opcode) {
2385  // We don't have atomicrmw operands for *, %, /, <<, >>
2386  case BO_MulAssign: case BO_DivAssign:
2387  case BO_RemAssign:
2388  case BO_ShlAssign:
2389  case BO_ShrAssign:
2390  break;
2391  case BO_AddAssign:
2392  aop = llvm::AtomicRMWInst::Add;
2393  break;
2394  case BO_SubAssign:
2395  aop = llvm::AtomicRMWInst::Sub;
2396  break;
2397  case BO_AndAssign:
2399  break;
2400  case BO_XorAssign:
2401  aop = llvm::AtomicRMWInst::Xor;
2402  break;
2403  case BO_OrAssign:
2404  aop = llvm::AtomicRMWInst::Or;
2405  break;
2406  default:
2407  llvm_unreachable("Invalid compound assignment type");
2408  }
2409  if (aop != llvm::AtomicRMWInst::BAD_BINOP) {
2410  llvm::Value *amt = CGF.EmitToMemory(
2411  EmitScalarConversion(OpInfo.RHS, E->getRHS()->getType(), LHSTy,
2412  E->getExprLoc()),
2413  LHSTy);
2414  Builder.CreateAtomicRMW(aop, LHSLV.getPointer(), amt,
2415  llvm::AtomicOrdering::SequentiallyConsistent);
2416  return LHSLV;
2417  }
2418  }
2419  // FIXME: For floating point types, we should be saving and restoring the
2420  // floating point environment in the loop.
2421  llvm::BasicBlock *startBB = Builder.GetInsertBlock();
2422  llvm::BasicBlock *opBB = CGF.createBasicBlock("atomic_op", CGF.CurFn);
2423  OpInfo.LHS = EmitLoadOfLValue(LHSLV, E->getExprLoc());
2424  OpInfo.LHS = CGF.EmitToMemory(OpInfo.LHS, type);
2425  Builder.CreateBr(opBB);
2426  Builder.SetInsertPoint(opBB);
2427  atomicPHI = Builder.CreatePHI(OpInfo.LHS->getType(), 2);
2428  atomicPHI->addIncoming(OpInfo.LHS, startBB);
2429  OpInfo.LHS = atomicPHI;
2430  }
2431  else
2432  OpInfo.LHS = EmitLoadOfLValue(LHSLV, E->getExprLoc());
2433 
2434  SourceLocation Loc = E->getExprLoc();
2435  OpInfo.LHS =
2436  EmitScalarConversion(OpInfo.LHS, LHSTy, E->getComputationLHSType(), Loc);
2437 
2438  // Expand the binary operator.
2439  Result = (this->*Func)(OpInfo);
2440 
2441  // Convert the result back to the LHS type.
2442  Result =
2443  EmitScalarConversion(Result, E->getComputationResultType(), LHSTy, Loc);
2444 
2445  if (atomicPHI) {
2446  llvm::BasicBlock *opBB = Builder.GetInsertBlock();
2447  llvm::BasicBlock *contBB = CGF.createBasicBlock("atomic_cont", CGF.CurFn);
2448  auto Pair = CGF.EmitAtomicCompareExchange(
2449  LHSLV, RValue::get(atomicPHI), RValue::get(Result), E->getExprLoc());
2450  llvm::Value *old = CGF.EmitToMemory(Pair.first.getScalarVal(), LHSTy);
2451  llvm::Value *success = Pair.second;
2452  atomicPHI->addIncoming(old, opBB);
2453  Builder.CreateCondBr(success, contBB, opBB);
2454  Builder.SetInsertPoint(contBB);
2455  return LHSLV;
2456  }
2457 
2458  // Store the result value into the LHS lvalue. Bit-fields are handled
2459  // specially because the result is altered by the store, i.e., [C99 6.5.16p1]
2460  // 'An assignment expression has the value of the left operand after the
2461  // assignment...'.
2462  if (LHSLV.isBitField())
2463  CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, &Result);
2464  else
2465  CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV);
2466 
2467  return LHSLV;
2468 }
2469 
2470 Value *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E,
2471  Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) {
2472  bool Ignore = TestAndClearIgnoreResultAssign();
2473  Value *RHS;
2474  LValue LHS = EmitCompoundAssignLValue(E, Func, RHS);
2475 
2476  // If the result is clearly ignored, return now.
2477  if (Ignore)
2478  return nullptr;
2479 
2480  // The result of an assignment in C is the assigned r-value.
2481  if (!CGF.getLangOpts().CPlusPlus)
2482  return RHS;
2483 
2484  // If the lvalue is non-volatile, return the computed value of the assignment.
2485  if (!LHS.isVolatileQualified())
2486  return RHS;
2487 
2488  // Otherwise, reload the value.
2489  return EmitLoadOfLValue(LHS, E->getExprLoc());
2490 }
2491 
2492 void ScalarExprEmitter::EmitUndefinedBehaviorIntegerDivAndRemCheck(
2493  const BinOpInfo &Ops, llvm::Value *Zero, bool isDiv) {
2495 
2496  if (CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero)) {
2497  Checks.push_back(std::make_pair(Builder.CreateICmpNE(Ops.RHS, Zero),
2498  SanitizerKind::IntegerDivideByZero));
2499  }
2500 
2501  const auto *BO = cast<BinaryOperator>(Ops.E);
2502  if (CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow) &&
2503  Ops.Ty->hasSignedIntegerRepresentation() &&
2504  !IsWidenedIntegerOp(CGF.getContext(), BO->getLHS()) &&
2505  Ops.mayHaveIntegerOverflow()) {
2506  llvm::IntegerType *Ty = cast<llvm::IntegerType>(Zero->getType());
2507 
2508  llvm::Value *IntMin =
2509  Builder.getInt(llvm::APInt::getSignedMinValue(Ty->getBitWidth()));
2510  llvm::Value *NegOne = llvm::ConstantInt::get(Ty, -1ULL);
2511 
2512  llvm::Value *LHSCmp = Builder.CreateICmpNE(Ops.LHS, IntMin);
2513  llvm::Value *RHSCmp = Builder.CreateICmpNE(Ops.RHS, NegOne);
2514  llvm::Value *NotOverflow = Builder.CreateOr(LHSCmp, RHSCmp, "or");
2515  Checks.push_back(
2516  std::make_pair(NotOverflow, SanitizerKind::SignedIntegerOverflow));
2517  }
2518 
2519  if (Checks.size() > 0)
2520  EmitBinOpCheck(Checks, Ops);
2521 }
2522 
2523 Value *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) {
2524  {
2525  CodeGenFunction::SanitizerScope SanScope(&CGF);
2526  if ((CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero) ||
2527  CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) &&
2528  Ops.Ty->isIntegerType() &&
2529  (Ops.mayHaveIntegerDivisionByZero() || Ops.mayHaveIntegerOverflow())) {
2530  llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
2531  EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, true);
2532  } else if (CGF.SanOpts.has(SanitizerKind::FloatDivideByZero) &&
2533  Ops.Ty->isRealFloatingType() &&
2534  Ops.mayHaveFloatDivisionByZero()) {
2535  llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
2536  llvm::Value *NonZero = Builder.CreateFCmpUNE(Ops.RHS, Zero);
2537  EmitBinOpCheck(std::make_pair(NonZero, SanitizerKind::FloatDivideByZero),
2538  Ops);
2539  }
2540  }
2541 
2542  if (Ops.LHS->getType()->isFPOrFPVectorTy()) {
2543  llvm::Value *Val = Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div");
2544  if (CGF.getLangOpts().OpenCL &&
2545  !CGF.CGM.getCodeGenOpts().CorrectlyRoundedDivSqrt) {
2546  // OpenCL v1.1 s7.4: minimum accuracy of single precision / is 2.5ulp
2547  // OpenCL v1.2 s5.6.4.2: The -cl-fp32-correctly-rounded-divide-sqrt
2548  // build option allows an application to specify that single precision
2549  // floating-point divide (x/y and 1/x) and sqrt used in the program
2550  // source are correctly rounded.
2551  llvm::Type *ValTy = Val->getType();
2552  if (ValTy->isFloatTy() ||
2553  (isa<llvm::VectorType>(ValTy) &&
2554  cast<llvm::VectorType>(ValTy)->getElementType()->isFloatTy()))
2555  CGF.SetFPAccuracy(Val, 2.5);
2556  }
2557  return Val;
2558  }
2559  else if (Ops.Ty->hasUnsignedIntegerRepresentation())
2560  return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div");
2561  else
2562  return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div");
2563 }
2564 
2565 Value *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) {
2566  // Rem in C can't be a floating point type: C99 6.5.5p2.
2567  if ((CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero) ||
2568  CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) &&
2569  Ops.Ty->isIntegerType() &&
2570  (Ops.mayHaveIntegerDivisionByZero() || Ops.mayHaveIntegerOverflow())) {
2571  CodeGenFunction::SanitizerScope SanScope(&CGF);
2572  llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
2573  EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, false);
2574  }
2575 
2576  if (Ops.Ty->hasUnsignedIntegerRepresentation())
2577  return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem");
2578  else
2579  return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem");
2580 }
2581 
2582 Value *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) {
2583  unsigned IID;
2584  unsigned OpID = 0;
2585 
2586  bool isSigned = Ops.Ty->isSignedIntegerOrEnumerationType();
2587  switch (Ops.Opcode) {
2588  case BO_Add:
2589  case BO_AddAssign:
2590  OpID = 1;
2591  IID = isSigned ? llvm::Intrinsic::sadd_with_overflow :
2592  llvm::Intrinsic::uadd_with_overflow;
2593  break;
2594  case BO_Sub:
2595  case BO_SubAssign:
2596  OpID = 2;
2597  IID = isSigned ? llvm::Intrinsic::ssub_with_overflow :
2598  llvm::Intrinsic::usub_with_overflow;
2599  break;
2600  case BO_Mul:
2601  case BO_MulAssign:
2602  OpID = 3;
2603  IID = isSigned ? llvm::Intrinsic::smul_with_overflow :
2604  llvm::Intrinsic::umul_with_overflow;
2605  break;
2606  default:
2607  llvm_unreachable("Unsupported operation for overflow detection");
2608  }
2609  OpID <<= 1;
2610  if (isSigned)
2611  OpID |= 1;
2612 
2613  CodeGenFunction::SanitizerScope SanScope(&CGF);
2614  llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty);
2615 
2616  llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, opTy);
2617 
2618  Value *resultAndOverflow = Builder.CreateCall(intrinsic, {Ops.LHS, Ops.RHS});
2619  Value *result = Builder.CreateExtractValue(resultAndOverflow, 0);
2620  Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1);
2621 
2622  // Handle overflow with llvm.trap if no custom handler has been specified.
2623  const std::string *handlerName =
2625  if (handlerName->empty()) {
2626  // If the signed-integer-overflow sanitizer is enabled, emit a call to its
2627  // runtime. Otherwise, this is a -ftrapv check, so just emit a trap.
2628  if (!isSigned || CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) {
2629  llvm::Value *NotOverflow = Builder.CreateNot(overflow);
2630  SanitizerMask Kind = isSigned ? SanitizerKind::SignedIntegerOverflow
2631  : SanitizerKind::UnsignedIntegerOverflow;
2632  EmitBinOpCheck(std::make_pair(NotOverflow, Kind), Ops);
2633  } else
2634  CGF.EmitTrapCheck(Builder.CreateNot(overflow));
2635  return result;
2636  }
2637 
2638  // Branch in case of overflow.
2639  llvm::BasicBlock *initialBB = Builder.GetInsertBlock();
2640  llvm::BasicBlock *continueBB =
2641  CGF.createBasicBlock("nooverflow", CGF.CurFn, initialBB->getNextNode());
2642  llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn);
2643 
2644  Builder.CreateCondBr(overflow, overflowBB, continueBB);
2645 
2646  // If an overflow handler is set, then we want to call it and then use its
2647  // result, if it returns.
2648  Builder.SetInsertPoint(overflowBB);
2649 
2650  // Get the overflow handler.
2651  llvm::Type *Int8Ty = CGF.Int8Ty;
2652  llvm::Type *argTypes[] = { CGF.Int64Ty, CGF.Int64Ty, Int8Ty, Int8Ty };
2653  llvm::FunctionType *handlerTy =
2654  llvm::FunctionType::get(CGF.Int64Ty, argTypes, true);
2655  llvm::Value *handler = CGF.CGM.CreateRuntimeFunction(handlerTy, *handlerName);
2656 
2657  // Sign extend the args to 64-bit, so that we can use the same handler for
2658  // all types of overflow.
2659  llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty);
2660  llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty);
2661 
2662  // Call the handler with the two arguments, the operation, and the size of
2663  // the result.
2664  llvm::Value *handlerArgs[] = {
2665  lhs,
2666  rhs,
2667  Builder.getInt8(OpID),
2668  Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth())
2669  };
2670  llvm::Value *handlerResult =
2671  CGF.EmitNounwindRuntimeCall(handler, handlerArgs);
2672 
2673  // Truncate the result back to the desired size.
2674  handlerResult = Builder.CreateTrunc(handlerResult, opTy);
2675  Builder.CreateBr(continueBB);
2676 
2677  Builder.SetInsertPoint(continueBB);
2678  llvm::PHINode *phi = Builder.CreatePHI(opTy, 2);
2679  phi->addIncoming(result, initialBB);
2680  phi->addIncoming(handlerResult, overflowBB);
2681 
2682  return phi;
2683 }
2684 
2685 /// Emit pointer + index arithmetic.
2687  const BinOpInfo &op,
2688  bool isSubtraction) {
2689  // Must have binary (not unary) expr here. Unary pointer
2690  // increment/decrement doesn't use this path.
2691  const BinaryOperator *expr = cast<BinaryOperator>(op.E);
2692 
2693  Value *pointer = op.LHS;
2694  Expr *pointerOperand = expr->getLHS();
2695  Value *index = op.RHS;
2696  Expr *indexOperand = expr->getRHS();
2697 
2698  // In a subtraction, the LHS is always the pointer.
2699  if (!isSubtraction && !pointer->getType()->isPointerTy()) {
2700  std::swap(pointer, index);
2701  std::swap(pointerOperand, indexOperand);
2702  }
2703 
2704  bool isSigned = indexOperand->getType()->isSignedIntegerOrEnumerationType();
2705 
2706  unsigned width = cast<llvm::IntegerType>(index->getType())->getBitWidth();
2707  auto &DL = CGF.CGM.getDataLayout();
2708  auto PtrTy = cast<llvm::PointerType>(pointer->getType());
2709 
2710  // Some versions of glibc and gcc use idioms (particularly in their malloc
2711  // routines) that add a pointer-sized integer (known to be a pointer value)
2712  // to a null pointer in order to cast the value back to an integer or as
2713  // part of a pointer alignment algorithm. This is undefined behavior, but
2714  // we'd like to be able to compile programs that use it.
2715  //
2716  // Normally, we'd generate a GEP with a null-pointer base here in response
2717  // to that code, but it's also UB to dereference a pointer created that
2718  // way. Instead (as an acknowledged hack to tolerate the idiom) we will
2719  // generate a direct cast of the integer value to a pointer.
2720  //
2721  // The idiom (p = nullptr + N) is not met if any of the following are true:
2722  //
2723  // The operation is subtraction.
2724  // The index is not pointer-sized.
2725  // The pointer type is not byte-sized.
2726  //
2728  op.Opcode,
2729  expr->getLHS(),
2730  expr->getRHS()))
2731  return CGF.Builder.CreateIntToPtr(index, pointer->getType());
2732 
2733  if (width != DL.getTypeSizeInBits(PtrTy)) {
2734  // Zero-extend or sign-extend the pointer value according to
2735  // whether the index is signed or not.
2736  index = CGF.Builder.CreateIntCast(index, DL.getIntPtrType(PtrTy), isSigned,
2737  "idx.ext");
2738  }
2739 
2740  // If this is subtraction, negate the index.
2741  if (isSubtraction)
2742  index = CGF.Builder.CreateNeg(index, "idx.neg");
2743 
2744  if (CGF.SanOpts.has(SanitizerKind::ArrayBounds))
2745  CGF.EmitBoundsCheck(op.E, pointerOperand, index, indexOperand->getType(),
2746  /*Accessed*/ false);
2747 
2748  const PointerType *pointerType
2749  = pointerOperand->getType()->getAs<PointerType>();
2750  if (!pointerType) {
2751  QualType objectType = pointerOperand->getType()
2753  ->getPointeeType();
2754  llvm::Value *objectSize
2755  = CGF.CGM.getSize(CGF.getContext().getTypeSizeInChars(objectType));
2756 
2757  index = CGF.Builder.CreateMul(index, objectSize);
2758 
2759  Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
2760  result = CGF.Builder.CreateGEP(result, index, "add.ptr");
2761  return CGF.Builder.CreateBitCast(result, pointer->getType());
2762  }
2763 
2764  QualType elementType = pointerType->getPointeeType();
2765  if (const VariableArrayType *vla
2766  = CGF.getContext().getAsVariableArrayType(elementType)) {
2767  // The element count here is the total number of non-VLA elements.
2768  llvm::Value *numElements = CGF.getVLASize(vla).NumElts;
2769 
2770  // Effectively, the multiply by the VLA size is part of the GEP.
2771  // GEP indexes are signed, and scaling an index isn't permitted to
2772  // signed-overflow, so we use the same semantics for our explicit
2773  // multiply. We suppress this if overflow is not undefined behavior.
2774  if (CGF.getLangOpts().isSignedOverflowDefined()) {
2775  index = CGF.Builder.CreateMul(index, numElements, "vla.index");
2776  pointer = CGF.Builder.CreateGEP(pointer, index, "add.ptr");
2777  } else {
2778  index = CGF.Builder.CreateNSWMul(index, numElements, "vla.index");
2779  pointer =
2780  CGF.EmitCheckedInBoundsGEP(pointer, index, isSigned, isSubtraction,
2781  op.E->getExprLoc(), "add.ptr");
2782  }
2783  return pointer;
2784  }
2785 
2786  // Explicitly handle GNU void* and function pointer arithmetic extensions. The
2787  // GNU void* casts amount to no-ops since our void* type is i8*, but this is
2788  // future proof.
2789  if (elementType->isVoidType() || elementType->isFunctionType()) {
2790  Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
2791  result = CGF.Builder.CreateGEP(result, index, "add.ptr");
2792  return CGF.Builder.CreateBitCast(result, pointer->getType());
2793  }
2794 
2796  return CGF.Builder.CreateGEP(pointer, index, "add.ptr");
2797 
2798  return CGF.EmitCheckedInBoundsGEP(pointer, index, isSigned, isSubtraction,
2799  op.E->getExprLoc(), "add.ptr");
2800 }
2801 
2802 // Construct an fmuladd intrinsic to represent a fused mul-add of MulOp and
2803 // Addend. Use negMul and negAdd to negate the first operand of the Mul or
2804 // the add operand respectively. This allows fmuladd to represent a*b-c, or
2805 // c-a*b. Patterns in LLVM should catch the negated forms and translate them to
2806 // efficient operations.
2807 static Value* buildFMulAdd(llvm::BinaryOperator *MulOp, Value *Addend,
2808  const CodeGenFunction &CGF, CGBuilderTy &Builder,
2809  bool negMul, bool negAdd) {
2810  assert(!(negMul && negAdd) && "Only one of negMul and negAdd should be set.");
2811 
2812  Value *MulOp0 = MulOp->getOperand(0);
2813  Value *MulOp1 = MulOp->getOperand(1);
2814  if (negMul) {
2815  MulOp0 =
2816  Builder.CreateFSub(
2817  llvm::ConstantFP::getZeroValueForNegation(MulOp0->getType()), MulOp0,
2818  "neg");
2819  } else if (negAdd) {
2820  Addend =
2821  Builder.CreateFSub(
2822  llvm::ConstantFP::getZeroValueForNegation(Addend->getType()), Addend,
2823  "neg");
2824  }
2825 
2826  Value *FMulAdd = Builder.CreateCall(
2827  CGF.CGM.getIntrinsic(llvm::Intrinsic::fmuladd, Addend->getType()),
2828  {MulOp0, MulOp1, Addend});
2829  MulOp->eraseFromParent();
2830 
2831  return FMulAdd;
2832 }
2833 
2834 // Check whether it would be legal to emit an fmuladd intrinsic call to
2835 // represent op and if so, build the fmuladd.
2836 //
2837 // Checks that (a) the operation is fusable, and (b) -ffp-contract=on.
2838 // Does NOT check the type of the operation - it's assumed that this function
2839 // will be called from contexts where it's known that the type is contractable.
2840 static Value* tryEmitFMulAdd(const BinOpInfo &op,
2841  const CodeGenFunction &CGF, CGBuilderTy &Builder,
2842  bool isSub=false) {
2843 
2844  assert((op.Opcode == BO_Add || op.Opcode == BO_AddAssign ||
2845  op.Opcode == BO_Sub || op.Opcode == BO_SubAssign) &&
2846  "Only fadd/fsub can be the root of an fmuladd.");
2847 
2848  // Check whether this op is marked as fusable.
2849  if (!op.FPFeatures.allowFPContractWithinStatement())
2850  return nullptr;
2851 
2852  // We have a potentially fusable op. Look for a mul on one of the operands.
2853  // Also, make sure that the mul result isn't used directly. In that case,
2854  // there's no point creating a muladd operation.
2855  if (auto *LHSBinOp = dyn_cast<llvm::BinaryOperator>(op.LHS)) {
2856  if (LHSBinOp->getOpcode() == llvm::Instruction::FMul &&
2857  LHSBinOp->use_empty())
2858  return buildFMulAdd(LHSBinOp, op.RHS, CGF, Builder, false, isSub);
2859  }
2860  if (auto *RHSBinOp = dyn_cast<llvm::BinaryOperator>(op.RHS)) {
2861  if (RHSBinOp->getOpcode() == llvm::Instruction::FMul &&
2862  RHSBinOp->use_empty())
2863  return buildFMulAdd(RHSBinOp, op.LHS, CGF, Builder, isSub, false);
2864  }
2865 
2866  return nullptr;
2867 }
2868 
2869 Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &op) {
2870  if (op.LHS->getType()->isPointerTy() ||
2871  op.RHS->getType()->isPointerTy())
2873 
2874  if (op.Ty->isSignedIntegerOrEnumerationType()) {
2875  switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
2877  return Builder.CreateAdd(op.LHS, op.RHS, "add");
2879  if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
2880  return Builder.CreateNSWAdd(op.LHS, op.RHS, "add");
2881  // Fall through.
2883  if (CanElideOverflowCheck(CGF.getContext(), op))
2884  return Builder.CreateNSWAdd(op.LHS, op.RHS, "add");
2885  return EmitOverflowCheckedBinOp(op);
2886  }
2887  }
2888 
2889  if (op.Ty->isUnsignedIntegerType() &&
2890  CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) &&
2891  !CanElideOverflowCheck(CGF.getContext(), op))
2892  return EmitOverflowCheckedBinOp(op);
2893 
2894  if (op.LHS->getType()->isFPOrFPVectorTy()) {
2895  // Try to form an fmuladd.
2896  if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder))
2897  return FMulAdd;
2898 
2899  Value *V = Builder.CreateFAdd(op.LHS, op.RHS, "add");
2900  return propagateFMFlags(V, op);
2901  }
2902 
2903  return Builder.CreateAdd(op.LHS, op.RHS, "add");
2904 }
2905 
2906 Value *ScalarExprEmitter::EmitSub(const BinOpInfo &op) {
2907  // The LHS is always a pointer if either side is.
2908  if (!op.LHS->getType()->isPointerTy()) {
2909  if (op.Ty->isSignedIntegerOrEnumerationType()) {
2910  switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
2912  return Builder.CreateSub(op.LHS, op.RHS, "sub");
2914  if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
2915  return Builder.CreateNSWSub(op.LHS, op.RHS, "sub");
2916  // Fall through.
2918  if (CanElideOverflowCheck(CGF.getContext(), op))
2919  return Builder.CreateNSWSub(op.LHS, op.RHS, "sub");
2920  return EmitOverflowCheckedBinOp(op);
2921  }
2922  }
2923 
2924  if (op.Ty->isUnsignedIntegerType() &&
2925  CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) &&
2926  !CanElideOverflowCheck(CGF.getContext(), op))
2927  return EmitOverflowCheckedBinOp(op);
2928 
2929  if (op.LHS->getType()->isFPOrFPVectorTy()) {
2930  // Try to form an fmuladd.
2931  if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder, true))
2932  return FMulAdd;
2933  Value *V = Builder.CreateFSub(op.LHS, op.RHS, "sub");
2934  return propagateFMFlags(V, op);
2935  }
2936 
2937  return Builder.CreateSub(op.LHS, op.RHS, "sub");
2938  }
2939 
2940  // If the RHS is not a pointer, then we have normal pointer
2941  // arithmetic.
2942  if (!op.RHS->getType()->isPointerTy())
2944 
2945  // Otherwise, this is a pointer subtraction.
2946 
2947  // Do the raw subtraction part.
2948  llvm::Value *LHS
2949  = Builder.CreatePtrToInt(op.LHS, CGF.PtrDiffTy, "sub.ptr.lhs.cast");
2950  llvm::Value *RHS
2951  = Builder.CreatePtrToInt(op.RHS, CGF.PtrDiffTy, "sub.ptr.rhs.cast");
2952  Value *diffInChars = Builder.CreateSub(LHS, RHS, "sub.ptr.sub");
2953 
2954  // Okay, figure out the element size.
2955  const BinaryOperator *expr = cast<BinaryOperator>(op.E);
2956  QualType elementType = expr->getLHS()->getType()->getPointeeType();
2957 
2958  llvm::Value *divisor = nullptr;
2959 
2960  // For a variable-length array, this is going to be non-constant.
2961  if (const VariableArrayType *vla
2962  = CGF.getContext().getAsVariableArrayType(elementType)) {
2963  auto VlaSize = CGF.getVLASize(vla);
2964  elementType = VlaSize.Type;
2965  divisor = VlaSize.NumElts;
2966 
2967  // Scale the number of non-VLA elements by the non-VLA element size.
2968  CharUnits eltSize = CGF.getContext().getTypeSizeInChars(elementType);
2969  if (!eltSize.isOne())
2970  divisor = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), divisor);
2971 
2972  // For everything elese, we can just compute it, safe in the
2973  // assumption that Sema won't let anything through that we can't
2974  // safely compute the size of.
2975  } else {
2976  CharUnits elementSize;
2977  // Handle GCC extension for pointer arithmetic on void* and
2978  // function pointer types.
2979  if (elementType->isVoidType() || elementType->isFunctionType())
2980  elementSize = CharUnits::One();
2981  else
2982  elementSize = CGF.getContext().getTypeSizeInChars(elementType);
2983 
2984  // Don't even emit the divide for element size of 1.
2985  if (elementSize.isOne())
2986  return diffInChars;
2987 
2988  divisor = CGF.CGM.getSize(elementSize);
2989  }
2990 
2991  // Otherwise, do a full sdiv. This uses the "exact" form of sdiv, since
2992  // pointer difference in C is only defined in the case where both operands
2993  // are pointing to elements of an array.
2994  return Builder.CreateExactSDiv(diffInChars, divisor, "sub.ptr.div");
2995 }
2996 
2997 Value *ScalarExprEmitter::GetWidthMinusOneValue(Value* LHS,Value* RHS) {
2998  llvm::IntegerType *Ty;
2999  if (llvm::VectorType *VT = dyn_cast<llvm::VectorType>(LHS->getType()))
3000  Ty = cast<llvm::IntegerType>(VT->getElementType());
3001  else
3002  Ty = cast<llvm::IntegerType>(LHS->getType());
3003  return llvm::ConstantInt::get(RHS->getType(), Ty->getBitWidth() - 1);
3004 }
3005 
3006 Value *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) {
3007  // LLVM requires the LHS and RHS to be the same type: promote or truncate the
3008  // RHS to the same size as the LHS.
3009  Value *RHS = Ops.RHS;
3010  if (Ops.LHS->getType() != RHS->getType())
3011  RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
3012 
3013  bool SanitizeBase = CGF.SanOpts.has(SanitizerKind::ShiftBase) &&
3014  Ops.Ty->hasSignedIntegerRepresentation() &&
3016  bool SanitizeExponent = CGF.SanOpts.has(SanitizerKind::ShiftExponent);
3017  // OpenCL 6.3j: shift values are effectively % word size of LHS.
3018  if (CGF.getLangOpts().OpenCL)
3019  RHS =
3020  Builder.CreateAnd(RHS, GetWidthMinusOneValue(Ops.LHS, RHS), "shl.mask");
3021  else if ((SanitizeBase || SanitizeExponent) &&
3022  isa<llvm::IntegerType>(Ops.LHS->getType())) {
3023  CodeGenFunction::SanitizerScope SanScope(&CGF);
3025  llvm::Value *WidthMinusOne = GetWidthMinusOneValue(Ops.LHS, Ops.RHS);
3026  llvm::Value *ValidExponent = Builder.CreateICmpULE(Ops.RHS, WidthMinusOne);
3027 
3028  if (SanitizeExponent) {
3029  Checks.push_back(
3030  std::make_pair(ValidExponent, SanitizerKind::ShiftExponent));
3031  }
3032 
3033  if (SanitizeBase) {
3034  // Check whether we are shifting any non-zero bits off the top of the
3035  // integer. We only emit this check if exponent is valid - otherwise
3036  // instructions below will have undefined behavior themselves.
3037  llvm::BasicBlock *Orig = Builder.GetInsertBlock();
3038  llvm::BasicBlock *Cont = CGF.createBasicBlock("cont");
3039  llvm::BasicBlock *CheckShiftBase = CGF.createBasicBlock("check");
3040  Builder.CreateCondBr(ValidExponent, CheckShiftBase, Cont);
3041  llvm::Value *PromotedWidthMinusOne =
3042  (RHS == Ops.RHS) ? WidthMinusOne
3043  : GetWidthMinusOneValue(Ops.LHS, RHS);
3044  CGF.EmitBlock(CheckShiftBase);
3045  llvm::Value *BitsShiftedOff = Builder.CreateLShr(
3046  Ops.LHS, Builder.CreateSub(PromotedWidthMinusOne, RHS, "shl.zeros",
3047  /*NUW*/ true, /*NSW*/ true),
3048  "shl.check");
3049  if (CGF.getLangOpts().CPlusPlus) {
3050  // In C99, we are not permitted to shift a 1 bit into the sign bit.
3051  // Under C++11's rules, shifting a 1 bit into the sign bit is
3052  // OK, but shifting a 1 bit out of it is not. (C89 and C++03 don't
3053  // define signed left shifts, so we use the C99 and C++11 rules there).
3054  llvm::Value *One = llvm::ConstantInt::get(BitsShiftedOff->getType(), 1);
3055  BitsShiftedOff = Builder.CreateLShr(BitsShiftedOff, One);
3056  }
3057  llvm::Value *Zero = llvm::ConstantInt::get(BitsShiftedOff->getType(), 0);
3058  llvm::Value *ValidBase = Builder.CreateICmpEQ(BitsShiftedOff, Zero);
3059  CGF.EmitBlock(Cont);
3060  llvm::PHINode *BaseCheck = Builder.CreatePHI(ValidBase->getType(), 2);
3061  BaseCheck->addIncoming(Builder.getTrue(), Orig);
3062  BaseCheck->addIncoming(ValidBase, CheckShiftBase);
3063  Checks.push_back(std::make_pair(BaseCheck, SanitizerKind::ShiftBase));
3064  }
3065 
3066  assert(!Checks.empty());
3067  EmitBinOpCheck(Checks, Ops);
3068  }
3069 
3070  return Builder.CreateShl(Ops.LHS, RHS, "shl");
3071 }
3072 
3073 Value *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) {
3074  // LLVM requires the LHS and RHS to be the same type: promote or truncate the
3075  // RHS to the same size as the LHS.
3076  Value *RHS = Ops.RHS;
3077  if (Ops.LHS->getType() != RHS->getType())
3078  RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
3079 
3080  // OpenCL 6.3j: shift values are effectively % word size of LHS.
3081  if (CGF.getLangOpts().OpenCL)
3082  RHS =
3083  Builder.CreateAnd(RHS, GetWidthMinusOneValue(Ops.LHS, RHS), "shr.mask");
3084  else if (CGF.SanOpts.has(SanitizerKind::ShiftExponent) &&
3085  isa<llvm::IntegerType>(Ops.LHS->getType())) {
3086  CodeGenFunction::SanitizerScope SanScope(&CGF);
3087  llvm::Value *Valid =
3088  Builder.CreateICmpULE(RHS, GetWidthMinusOneValue(Ops.LHS, RHS));
3089  EmitBinOpCheck(std::make_pair(Valid, SanitizerKind::ShiftExponent), Ops);
3090  }
3091 
3092  if (Ops.Ty->hasUnsignedIntegerRepresentation())
3093  return Builder.CreateLShr(Ops.LHS, RHS, "shr");
3094  return Builder.CreateAShr(Ops.LHS, RHS, "shr");
3095 }
3096 
3098 // return corresponding comparison intrinsic for given vector type
3100  BuiltinType::Kind ElemKind) {
3101  switch (ElemKind) {
3102  default: llvm_unreachable("unexpected element type");
3103  case BuiltinType::Char_U:
3104  case BuiltinType::UChar:
3105  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p :
3106  llvm::Intrinsic::ppc_altivec_vcmpgtub_p;
3107  case BuiltinType::Char_S:
3108  case BuiltinType::SChar:
3109  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p :
3110  llvm::Intrinsic::ppc_altivec_vcmpgtsb_p;
3111  case BuiltinType::UShort:
3112  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p :
3113  llvm::Intrinsic::ppc_altivec_vcmpgtuh_p;
3114  case BuiltinType::Short:
3115  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p :
3116  llvm::Intrinsic::ppc_altivec_vcmpgtsh_p;
3117  case BuiltinType::UInt:
3118  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p :
3119  llvm::Intrinsic::ppc_altivec_vcmpgtuw_p;
3120  case BuiltinType::Int:
3121  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p :
3122  llvm::Intrinsic::ppc_altivec_vcmpgtsw_p;
3123  case BuiltinType::ULong:
3124  case BuiltinType::ULongLong:
3125  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequd_p :
3126  llvm::Intrinsic::ppc_altivec_vcmpgtud_p;
3127  case BuiltinType::Long:
3128  case BuiltinType::LongLong:
3129  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequd_p :
3130  llvm::Intrinsic::ppc_altivec_vcmpgtsd_p;
3131  case BuiltinType::Float:
3132  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpeqfp_p :
3133  llvm::Intrinsic::ppc_altivec_vcmpgtfp_p;
3134  case BuiltinType::Double:
3135  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_vsx_xvcmpeqdp_p :
3136  llvm::Intrinsic::ppc_vsx_xvcmpgtdp_p;
3137  }
3138 }
3139 
3141  llvm::CmpInst::Predicate UICmpOpc,
3142  llvm::CmpInst::Predicate SICmpOpc,
3143  llvm::CmpInst::Predicate FCmpOpc) {
3144  TestAndClearIgnoreResultAssign();
3145  Value *Result;
3146  QualType LHSTy = E->getLHS()->getType();
3147  QualType RHSTy = E->getRHS()->getType();
3148  if (const MemberPointerType *MPT = LHSTy->getAs<MemberPointerType>()) {
3149  assert(E->getOpcode() == BO_EQ ||
3150  E->getOpcode() == BO_NE);
3151  Value *LHS = CGF.EmitScalarExpr(E->getLHS());
3152  Value *RHS = CGF.EmitScalarExpr(E->getRHS());
3153  Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison(
3154  CGF, LHS, RHS, MPT, E->getOpcode() == BO_NE);
3155  } else if (!LHSTy->isAnyComplexType() && !RHSTy->isAnyComplexType()) {
3156  Value *LHS = Visit(E->getLHS());
3157  Value *RHS = Visit(E->getRHS());
3158 
3159  // If AltiVec, the comparison results in a numeric type, so we use
3160  // intrinsics comparing vectors and giving 0 or 1 as a result
3161  if (LHSTy->isVectorType() && !E->getType()->isVectorType()) {
3162  // constants for mapping CR6 register bits to predicate result
3163  enum { CR6_EQ=0, CR6_EQ_REV, CR6_LT, CR6_LT_REV } CR6;
3164 
3165  llvm::Intrinsic::ID ID = llvm::Intrinsic::not_intrinsic;
3166 
3167  // in several cases vector arguments order will be reversed
3168  Value *FirstVecArg = LHS,
3169  *SecondVecArg = RHS;
3170 
3171  QualType ElTy = LHSTy->getAs<VectorType>()->getElementType();
3172  const BuiltinType *BTy = ElTy->getAs<BuiltinType>();
3173  BuiltinType::Kind ElementKind = BTy->getKind();
3174 
3175  switch(E->getOpcode()) {
3176  default: llvm_unreachable("is not a comparison operation");
3177  case BO_EQ:
3178  CR6 = CR6_LT;
3179  ID = GetIntrinsic(VCMPEQ, ElementKind);
3180  break;
3181  case BO_NE:
3182  CR6 = CR6_EQ;
3183  ID = GetIntrinsic(VCMPEQ, ElementKind);
3184  break;
3185  case BO_LT:
3186  CR6 = CR6_LT;
3187  ID = GetIntrinsic(VCMPGT, ElementKind);
3188  std::swap(FirstVecArg, SecondVecArg);
3189  break;
3190  case BO_GT:
3191  CR6 = CR6_LT;
3192  ID = GetIntrinsic(VCMPGT, ElementKind);
3193  break;
3194  case BO_LE:
3195  if (ElementKind == BuiltinType::Float) {
3196  CR6 = CR6_LT;
3197  ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p;
3198  std::swap(FirstVecArg, SecondVecArg);
3199  }
3200  else {
3201  CR6 = CR6_EQ;
3202  ID = GetIntrinsic(VCMPGT, ElementKind);
3203  }
3204  break;
3205  case BO_GE:
3206  if (ElementKind == BuiltinType::Float) {
3207  CR6 = CR6_LT;
3208  ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p;
3209  }
3210  else {
3211  CR6 = CR6_EQ;
3212  ID = GetIntrinsic(VCMPGT, ElementKind);
3213  std::swap(FirstVecArg, SecondVecArg);
3214  }
3215  break;
3216  }
3217 
3218  Value *CR6Param = Builder.getInt32(CR6);
3219  llvm::Function *F = CGF.CGM.getIntrinsic(ID);
3220  Result = Builder.CreateCall(F, {CR6Param, FirstVecArg, SecondVecArg});
3221 
3222  // The result type of intrinsic may not be same as E->getType().
3223  // If E->getType() is not BoolTy, EmitScalarConversion will do the
3224  // conversion work. If E->getType() is BoolTy, EmitScalarConversion will
3225  // do nothing, if ResultTy is not i1 at the same time, it will cause
3226  // crash later.
3227  llvm::IntegerType *ResultTy = cast<llvm::IntegerType>(Result->getType());
3228  if (ResultTy->getBitWidth() > 1 &&
3229  E->getType() == CGF.getContext().BoolTy)
3230  Result = Builder.CreateTrunc(Result, Builder.getInt1Ty());
3231  return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType(),
3232  E->getExprLoc());
3233  }
3234 
3235  if (LHS->getType()->isFPOrFPVectorTy()) {
3236  Result = Builder.CreateFCmp(FCmpOpc, LHS, RHS, "cmp");
3237  } else if (LHSTy->hasSignedIntegerRepresentation()) {
3238  Result = Builder.CreateICmp(SICmpOpc, LHS, RHS, "cmp");
3239  } else {
3240  // Unsigned integers and pointers.
3241  Result = Builder.CreateICmp(UICmpOpc, LHS, RHS, "cmp");
3242  }
3243 
3244  // If this is a vector comparison, sign extend the result to the appropriate
3245  // vector integer type and return it (don't convert to bool).
3246  if (LHSTy->isVectorType())
3247  return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
3248 
3249  } else {
3250  // Complex Comparison: can only be an equality comparison.
3252  QualType CETy;
3253  if (auto *CTy = LHSTy->getAs<ComplexType>()) {
3254  LHS = CGF.EmitComplexExpr(E->getLHS());
3255  CETy = CTy->getElementType();
3256  } else {
3257  LHS.first = Visit(E->getLHS());
3258  LHS.second = llvm::Constant::getNullValue(LHS.first->getType());
3259  CETy = LHSTy;
3260  }
3261  if (auto *CTy = RHSTy->getAs<ComplexType>()) {
3262  RHS = CGF.EmitComplexExpr(E->getRHS());
3263  assert(CGF.getContext().hasSameUnqualifiedType(CETy,
3264  CTy->getElementType()) &&
3265  "The element types must always match.");
3266  (void)CTy;
3267  } else {
3268  RHS.first = Visit(E->getRHS());
3269  RHS.second = llvm::Constant::getNullValue(RHS.first->getType());
3270  assert(CGF.getContext().hasSameUnqualifiedType(CETy, RHSTy) &&
3271  "The element types must always match.");
3272  }
3273 
3274  Value *ResultR, *ResultI;
3275  if (CETy->isRealFloatingType()) {
3276  ResultR = Builder.CreateFCmp(FCmpOpc, LHS.first, RHS.first, "cmp.r");
3277  ResultI = Builder.CreateFCmp(FCmpOpc, LHS.second, RHS.second, "cmp.i");
3278  } else {
3279  // Complex comparisons can only be equality comparisons. As such, signed
3280  // and unsigned opcodes are the same.
3281  ResultR = Builder.CreateICmp(UICmpOpc, LHS.first, RHS.first, "cmp.r");
3282  ResultI = Builder.CreateICmp(UICmpOpc, LHS.second, RHS.second, "cmp.i");
3283  }
3284 
3285  if (E->getOpcode() == BO_EQ) {
3286  Result = Builder.CreateAnd(ResultR, ResultI, "and.ri");
3287  } else {
3288  assert(E->getOpcode() == BO_NE &&
3289  "Complex comparison other than == or != ?");
3290  Result = Builder.CreateOr(ResultR, ResultI, "or.ri");
3291  }
3292  }
3293 
3294  return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType(),
3295  E->getExprLoc());
3296 }
3297 
3298 Value *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) {
3299  bool Ignore = TestAndClearIgnoreResultAssign();
3300 
3301  Value *RHS;
3302  LValue LHS;
3303 
3304  switch (E->getLHS()->getType().getObjCLifetime()) {
3306  std::tie(LHS, RHS) = CGF.EmitARCStoreStrong(E, Ignore);
3307  break;
3308 
3310  std::tie(LHS, RHS) = CGF.EmitARCStoreAutoreleasing(E);
3311  break;
3312 
3314  std::tie(LHS, RHS) = CGF.EmitARCStoreUnsafeUnretained(E, Ignore);
3315  break;
3316 
3317  case Qualifiers::OCL_Weak:
3318  RHS = Visit(E->getRHS());
3319  LHS = EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
3320  RHS = CGF.EmitARCStoreWeak(LHS.getAddress(), RHS, Ignore);
3321  break;
3322 
3323  case Qualifiers::OCL_None:
3324  // __block variables need to have the rhs evaluated first, plus
3325  // this should improve codegen just a little.
3326  RHS = Visit(E->getRHS());
3327  LHS = EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
3328 
3329  // Store the value into the LHS. Bit-fields are handled specially
3330  // because the result is altered by the store, i.e., [C99 6.5.16p1]
3331  // 'An assignment expression has the value of the left operand after
3332  // the assignment...'.
3333  if (LHS.isBitField()) {
3334  CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, &RHS);
3335  } else {
3336  CGF.EmitNullabilityCheck(LHS, RHS, E->getExprLoc());
3337  CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS);
3338  }
3339  }
3340 
3341  // If the result is clearly ignored, return now.
3342  if (Ignore)
3343  return nullptr;
3344 
3345  // The result of an assignment in C is the assigned r-value.
3346  if (!CGF.getLangOpts().CPlusPlus)
3347  return RHS;
3348 
3349  // If the lvalue is non-volatile, return the computed value of the assignment.
3350  if (!LHS.isVolatileQualified())
3351  return RHS;
3352 
3353  // Otherwise, reload the value.
3354  return EmitLoadOfLValue(LHS, E->getExprLoc());
3355 }
3356 
3357 Value *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) {
3358  // Perform vector logical and on comparisons with zero vectors.
3359  if (E->getType()->isVectorType()) {
3360  CGF.incrementProfileCounter(E);
3361 
3362  Value *LHS = Visit(E->getLHS());
3363  Value *RHS = Visit(E->getRHS());
3364  Value *Zero = llvm::ConstantAggregateZero::get(LHS->getType());
3365  if (LHS->getType()->isFPOrFPVectorTy()) {
3366  LHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero, "cmp");
3367  RHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero, "cmp");
3368  } else {
3369  LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp");
3370  RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp");
3371  }
3372  Value *And = Builder.CreateAnd(LHS, RHS);
3373  return Builder.CreateSExt(And, ConvertType(E->getType()), "sext");
3374  }
3375 
3376  llvm::Type *ResTy = ConvertType(E->getType());
3377 
3378  // If we have 0 && RHS, see if we can elide RHS, if so, just return 0.
3379  // If we have 1 && X, just emit X without inserting the control flow.
3380  bool LHSCondVal;
3381  if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) {
3382  if (LHSCondVal) { // If we have 1 && X, just emit X.
3383  CGF.incrementProfileCounter(E);
3384 
3385  Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
3386  // ZExt result to int or bool.
3387  return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext");
3388  }
3389 
3390  // 0 && RHS: If it is safe, just elide the RHS, and return 0/false.
3391  if (!CGF.ContainsLabel(E->getRHS()))
3392  return llvm::Constant::getNullValue(ResTy);
3393  }
3394 
3395  llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end");
3396  llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs");
3397 
3399 
3400  // Branch on the LHS first. If it is false, go to the failure (cont) block.
3401  CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock,
3402  CGF.getProfileCount(E->getRHS()));
3403 
3404  // Any edges into the ContBlock are now from an (indeterminate number of)
3405  // edges from this first condition. All of these values will be false. Start
3406  // setting up the PHI node in the Cont Block for this.
3407  llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2,
3408  "", ContBlock);
3409  for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock);
3410  PI != PE; ++PI)
3411  PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI);
3412 
3413  eval.begin(CGF);
3414  CGF.EmitBlock(RHSBlock);
3415  CGF.incrementProfileCounter(E);
3416  Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
3417  eval.end(CGF);
3418 
3419  // Reaquire the RHS block, as there may be subblocks inserted.
3420  RHSBlock = Builder.GetInsertBlock();
3421 
3422  // Emit an unconditional branch from this block to ContBlock.
3423  {
3424  // There is no need to emit line number for unconditional branch.
3425  auto NL = ApplyDebugLocation::CreateEmpty(CGF);
3426  CGF.EmitBlock(ContBlock);
3427  }
3428  // Insert an entry into the phi node for the edge with the value of RHSCond.
3429  PN->addIncoming(RHSCond, RHSBlock);
3430 
3431  // ZExt result to int.
3432  return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext");
3433 }
3434 
3435 Value *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) {
3436  // Perform vector logical or on comparisons with zero vectors.
3437  if (E->getType()->isVectorType()) {
3438  CGF.incrementProfileCounter(E);
3439 
3440  Value *LHS = Visit(E->getLHS());
3441  Value *RHS = Visit(E->getRHS());
3442  Value *Zero = llvm::ConstantAggregateZero::get(LHS->getType());
3443  if (LHS->getType()->isFPOrFPVectorTy()) {
3444  LHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero, "cmp");
3445  RHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero, "cmp");
3446  } else {
3447  LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp");
3448  RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp");
3449  }
3450  Value *Or = Builder.CreateOr(LHS, RHS);
3451  return Builder.CreateSExt(Or, ConvertType(E->getType()), "sext");
3452  }
3453 
3454  llvm::Type *ResTy = ConvertType(E->getType());
3455 
3456  // If we have 1 || RHS, see if we can elide RHS, if so, just return 1.
3457  // If we have 0 || X, just emit X without inserting the control flow.
3458  bool LHSCondVal;
3459  if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) {
3460  if (!LHSCondVal) { // If we have 0 || X, just emit X.
3461  CGF.incrementProfileCounter(E);
3462 
3463  Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
3464  // ZExt result to int or bool.
3465  return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext");
3466  }
3467 
3468  // 1 || RHS: If it is safe, just elide the RHS, and return 1/true.
3469  if (!CGF.ContainsLabel(E->getRHS()))
3470  return llvm::ConstantInt::get(ResTy, 1);
3471  }
3472 
3473  llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end");
3474  llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs");
3475 
3477 
3478  // Branch on the LHS first. If it is true, go to the success (cont) block.
3479  CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock,
3480  CGF.getCurrentProfileCount() -
3481  CGF.getProfileCount(E->getRHS()));
3482 
3483  // Any edges into the ContBlock are now from an (indeterminate number of)
3484  // edges from this first condition. All of these values will be true. Start
3485  // setting up the PHI node in the Cont Block for this.
3486  llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2,
3487  "", ContBlock);
3488  for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock);
3489  PI != PE; ++PI)
3490  PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI);
3491 
3492  eval.begin(CGF);
3493 
3494  // Emit the RHS condition as a bool value.
3495  CGF.EmitBlock(RHSBlock);
3496  CGF.incrementProfileCounter(E);
3497  Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
3498 
3499  eval.end(CGF);
3500 
3501  // Reaquire the RHS block, as there may be subblocks inserted.
3502  RHSBlock = Builder.GetInsertBlock();
3503 
3504  // Emit an unconditional branch from this block to ContBlock. Insert an entry
3505  // into the phi node for the edge with the value of RHSCond.
3506  CGF.EmitBlock(ContBlock);
3507  PN->addIncoming(RHSCond, RHSBlock);
3508 
3509  // ZExt result to int.
3510  return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext");
3511 }
3512 
3513 Value *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) {
3514  CGF.EmitIgnoredExpr(E->getLHS());
3515  CGF.EnsureInsertPoint();
3516  return Visit(E->getRHS());
3517 }
3518 
3519 //===----------------------------------------------------------------------===//
3520 // Other Operators
3521 //===----------------------------------------------------------------------===//
3522 
3523 /// isCheapEnoughToEvaluateUnconditionally - Return true if the specified
3524 /// expression is cheap enough and side-effect-free enough to evaluate
3525 /// unconditionally instead of conditionally. This is used to convert control
3526 /// flow into selects in some cases.
3528  CodeGenFunction &CGF) {
3529  // Anything that is an integer or floating point constant is fine.
3530  return E->IgnoreParens()->isEvaluatable(CGF.getContext());
3531 
3532  // Even non-volatile automatic variables can't be evaluated unconditionally.
3533  // Referencing a thread_local may cause non-trivial initialization work to
3534  // occur. If we're inside a lambda and one of the variables is from the scope
3535  // outside the lambda, that function may have returned already. Reading its
3536  // locals is a bad idea. Also, these reads may introduce races there didn't
3537  // exist in the source-level program.
3538 }
3539 
3540 
3541 Value *ScalarExprEmitter::
3542 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
3543  TestAndClearIgnoreResultAssign();
3544 
3545  // Bind the common expression if necessary.
3546  CodeGenFunction::OpaqueValueMapping binding(CGF, E);
3547 
3548  Expr *condExpr = E->getCond();
3549  Expr *lhsExpr = E->getTrueExpr();
3550  Expr *rhsExpr = E->getFalseExpr();
3551 
3552  // If the condition constant folds and can be elided, try to avoid emitting
3553  // the condition and the dead arm.
3554  bool CondExprBool;
3555  if (CGF.ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) {
3556  Expr *live = lhsExpr, *dead = rhsExpr;
3557  if (!CondExprBool) std::swap(live, dead);
3558 
3559  // If the dead side doesn't have labels we need, just emit the Live part.
3560  if (!CGF.ContainsLabel(dead)) {
3561  if (CondExprBool)
3562  CGF.incrementProfileCounter(E);
3563  Value *Result = Visit(live);
3564 
3565  // If the live part is a throw expression, it acts like it has a void
3566  // type, so evaluating it returns a null Value*. However, a conditional
3567  // with non-void type must return a non-null Value*.
3568  if (!Result && !E->getType()->isVoidType())
3569  Result = llvm::UndefValue::get(CGF.ConvertType(E->getType()));
3570 
3571  return Result;
3572  }
3573  }
3574 
3575  // OpenCL: If the condition is a vector, we can treat this condition like
3576  // the select function.
3577  if (CGF.getLangOpts().OpenCL
3578  && condExpr->getType()->isVectorType()) {
3579  CGF.incrementProfileCounter(E);
3580 
3581  llvm::Value *CondV = CGF.EmitScalarExpr(condExpr);
3582  llvm::Value *LHS = Visit(lhsExpr);
3583  llvm::Value *RHS = Visit(rhsExpr);
3584 
3585  llvm::Type *condType = ConvertType(condExpr->getType());
3586  llvm::VectorType *vecTy = cast<llvm::VectorType>(condType);
3587 
3588  unsigned numElem = vecTy->getNumElements();
3589  llvm::Type *elemType = vecTy->getElementType();
3590 
3591  llvm::Value *zeroVec = llvm::Constant::getNullValue(vecTy);
3592  llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec);
3593  llvm::Value *tmp = Builder.CreateSExt(TestMSB,
3594  llvm::VectorType::get(elemType,
3595  numElem),
3596  "sext");
3597  llvm::Value *tmp2 = Builder.CreateNot(tmp);
3598 
3599  // Cast float to int to perform ANDs if necessary.
3600  llvm::Value *RHSTmp = RHS;
3601  llvm::Value *LHSTmp = LHS;
3602  bool wasCast = false;
3603  llvm::VectorType *rhsVTy = cast<llvm::VectorType>(RHS->getType());
3604  if (rhsVTy->getElementType()->isFloatingPointTy()) {
3605  RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType());
3606  LHSTmp = Builder.CreateBitCast(LHS, tmp->getType());
3607  wasCast = true;
3608  }
3609 
3610  llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2);
3611  llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp);
3612  llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond");
3613  if (wasCast)
3614  tmp5 = Builder.CreateBitCast(tmp5, RHS->getType());
3615 
3616  return tmp5;
3617  }
3618 
3619  // If this is a really simple expression (like x ? 4 : 5), emit this as a
3620  // select instead of as control flow. We can only do this if it is cheap and
3621  // safe to evaluate the LHS and RHS unconditionally.
3622  if (isCheapEnoughToEvaluateUnconditionally(lhsExpr, CGF) &&
3624  llvm::Value *CondV = CGF.EvaluateExprAsBool(condExpr);
3625  llvm::Value *StepV = Builder.CreateZExtOrBitCast(CondV, CGF.Int64Ty);
3626 
3627  CGF.incrementProfileCounter(E, StepV);
3628 
3629  llvm::Value *LHS = Visit(lhsExpr);
3630  llvm::Value *RHS = Visit(rhsExpr);
3631  if (!LHS) {
3632  // If the conditional has void type, make sure we return a null Value*.
3633  assert(!RHS && "LHS and RHS types must match");
3634  return nullptr;
3635  }
3636  return Builder.CreateSelect(CondV, LHS, RHS, "cond");
3637  }
3638 
3639  llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
3640  llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
3641  llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
3642 
3644  CGF.EmitBranchOnBoolExpr(condExpr, LHSBlock, RHSBlock,
3645  CGF.getProfileCount(lhsExpr));
3646 
3647  CGF.EmitBlock(LHSBlock);
3648  CGF.incrementProfileCounter(E);
3649  eval.begin(CGF);
3650  Value *LHS = Visit(lhsExpr);
3651  eval.end(CGF);
3652 
3653  LHSBlock = Builder.GetInsertBlock();
3654  Builder.CreateBr(ContBlock);
3655 
3656  CGF.EmitBlock(RHSBlock);
3657  eval.begin(CGF);
3658  Value *RHS = Visit(rhsExpr);
3659  eval.end(CGF);
3660 
3661  RHSBlock = Builder.GetInsertBlock();
3662  CGF.EmitBlock(ContBlock);
3663 
3664  // If the LHS or RHS is a throw expression, it will be legitimately null.
3665  if (!LHS)
3666  return RHS;
3667  if (!RHS)
3668  return LHS;
3669 
3670  // Create a PHI node for the real part.
3671  llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), 2, "cond");
3672  PN->addIncoming(LHS, LHSBlock);
3673  PN->addIncoming(RHS, RHSBlock);
3674  return PN;
3675 }
3676 
3677 Value *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) {
3678  return Visit(E->getChosenSubExpr());
3679 }
3680 
3681 Value *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
3682  QualType Ty = VE->getType();
3683 
3684  if (Ty->isVariablyModifiedType())
3685  CGF.EmitVariablyModifiedType(Ty);
3686 
3687  Address ArgValue = Address::invalid();
3688  Address ArgPtr = CGF.EmitVAArg(VE, ArgValue);
3689 
3690  llvm::Type *ArgTy = ConvertType(VE->getType());
3691 
3692  // If EmitVAArg fails, emit an error.
3693  if (!ArgPtr.isValid()) {
3694  CGF.ErrorUnsupported(VE, "va_arg expression");
3695  return llvm::UndefValue::get(ArgTy);
3696  }
3697 
3698  // FIXME Volatility.
3699  llvm::Value *Val = Builder.CreateLoad(ArgPtr);
3700 
3701  // If EmitVAArg promoted the type, we must truncate it.
3702  if (ArgTy != Val->getType()) {
3703  if (ArgTy->isPointerTy() && !Val->getType()->isPointerTy())
3704  Val = Builder.CreateIntToPtr(Val, ArgTy);
3705  else
3706  Val = Builder.CreateTrunc(Val, ArgTy);
3707  }
3708 
3709  return Val;
3710 }
3711 
3712 Value *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *block) {
3713  return CGF.EmitBlockLiteral(block);
3714 }
3715 
3716 // Convert a vec3 to vec4, or vice versa.
3717 static Value *ConvertVec3AndVec4(CGBuilderTy &Builder, CodeGenFunction &CGF,
3718  Value *Src, unsigned NumElementsDst) {
3719  llvm::Value *UnV = llvm::UndefValue::get(Src->getType());
3721  Args.push_back(Builder.getInt32(0));
3722  Args.push_back(Builder.getInt32(1));
3723  Args.push_back(Builder.getInt32(2));
3724  if (NumElementsDst == 4)
3725  Args.push_back(llvm::UndefValue::get(CGF.Int32Ty));
3726  llvm::Constant *Mask = llvm::ConstantVector::get(Args);
3727  return Builder.CreateShuffleVector(Src, UnV, Mask);
3728 }
3729 
3730 // Create cast instructions for converting LLVM value \p Src to LLVM type \p
3731 // DstTy. \p Src has the same size as \p DstTy. Both are single value types
3732 // but could be scalar or vectors of different lengths, and either can be
3733 // pointer.
3734 // There are 4 cases:
3735 // 1. non-pointer -> non-pointer : needs 1 bitcast
3736 // 2. pointer -> pointer : needs 1 bitcast or addrspacecast
3737 // 3. pointer -> non-pointer
3738 // a) pointer -> intptr_t : needs 1 ptrtoint
3739 // b) pointer -> non-intptr_t : needs 1 ptrtoint then 1 bitcast
3740 // 4. non-pointer -> pointer
3741 // a) intptr_t -> pointer : needs 1 inttoptr
3742 // b) non-intptr_t -> pointer : needs 1 bitcast then 1 inttoptr
3743 // Note: for cases 3b and 4b two casts are required since LLVM casts do not
3744 // allow casting directly between pointer types and non-integer non-pointer
3745 // types.
3747  const llvm::DataLayout &DL,
3748  Value *Src, llvm::Type *DstTy,
3749  StringRef Name = "") {
3750  auto SrcTy = Src->getType();
3751 
3752  // Case 1.
3753  if (!SrcTy->isPointerTy() && !DstTy->isPointerTy())
3754  return Builder.CreateBitCast(Src, DstTy, Name);
3755 
3756  // Case 2.
3757  if (SrcTy->isPointerTy() && DstTy->isPointerTy())
3758  return Builder.CreatePointerBitCastOrAddrSpaceCast(Src, DstTy, Name);
3759 
3760  // Case 3.
3761  if (SrcTy->isPointerTy() && !DstTy->isPointerTy()) {
3762  // Case 3b.
3763  if (!DstTy->isIntegerTy())
3764  Src = Builder.CreatePtrToInt(Src, DL.getIntPtrType(SrcTy));
3765  // Cases 3a and 3b.
3766  return Builder.CreateBitOrPointerCast(Src, DstTy, Name);
3767  }
3768 
3769  // Case 4b.
3770  if (!SrcTy->isIntegerTy())
3771  Src = Builder.CreateBitCast(Src, DL.getIntPtrType(DstTy));
3772  // Cases 4a and 4b.
3773  return Builder.CreateIntToPtr(Src, DstTy, Name);
3774 }
3775 
3776 Value *ScalarExprEmitter::VisitAsTypeExpr(AsTypeExpr *E) {
3777  Value *Src = CGF.EmitScalarExpr(E->getSrcExpr());
3778  llvm::Type *DstTy = ConvertType(E->getType());
3779 
3780  llvm::Type *SrcTy = Src->getType();
3781  unsigned NumElementsSrc = isa<llvm::VectorType>(SrcTy) ?
3782  cast<llvm::VectorType>(SrcTy)->getNumElements() : 0;
3783  unsigned NumElementsDst = isa<llvm::VectorType>(DstTy) ?
3784  cast<llvm::VectorType>(DstTy)->getNumElements() : 0;
3785 
3786  // Going from vec3 to non-vec3 is a special case and requires a shuffle
3787  // vector to get a vec4, then a bitcast if the target type is different.
3788  if (NumElementsSrc == 3 && NumElementsDst != 3) {
3789  Src = ConvertVec3AndVec4(Builder, CGF, Src, 4);
3790 
3791  if (!CGF.CGM.getCodeGenOpts().PreserveVec3Type) {
3792  Src = createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(), Src,
3793  DstTy);
3794  }
3795 
3796  Src->setName("astype");
3797  return Src;
3798  }
3799 
3800  // Going from non-vec3 to vec3 is a special case and requires a bitcast
3801  // to vec4 if the original type is not vec4, then a shuffle vector to
3802  // get a vec3.
3803  if (NumElementsSrc != 3 && NumElementsDst == 3) {
3804  if (!CGF.CGM.getCodeGenOpts().PreserveVec3Type) {
3805  auto Vec4Ty = llvm::VectorType::get(DstTy->getVectorElementType(), 4);
3806  Src = createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(), Src,
3807  Vec4Ty);
3808  }
3809 
3810  Src = ConvertVec3AndVec4(Builder, CGF, Src, 3);
3811  Src->setName("astype");
3812  return Src;
3813  }
3814 
3815  return Src = createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(),
3816  Src, DstTy, "astype");
3817 }
3818 
3819 Value *ScalarExprEmitter::VisitAtomicExpr(AtomicExpr *E) {
3820  return CGF.EmitAtomicExpr(E).getScalarVal();
3821 }
3822 
3823 //===----------------------------------------------------------------------===//
3824 // Entry Point into this File
3825 //===----------------------------------------------------------------------===//
3826 
3827 /// Emit the computation of the specified expression of scalar type, ignoring
3828 /// the result.
3829 Value *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) {
3830  assert(E && hasScalarEvaluationKind(E->getType()) &&
3831  "Invalid scalar expression to emit");
3832 
3833  return ScalarExprEmitter(*this, IgnoreResultAssign)
3834  .Visit(const_cast<Expr *>(E));
3835 }
3836 
3837 /// Emit a conversion from the specified type to the specified destination type,
3838 /// both of which are LLVM scalar types.
3840  QualType DstTy,
3841  SourceLocation Loc) {
3842  assert(hasScalarEvaluationKind(SrcTy) && hasScalarEvaluationKind(DstTy) &&
3843  "Invalid scalar expression to emit");
3844  return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy, Loc);
3845 }
3846 
3847 /// Emit a conversion from the specified complex type to the specified
3848 /// destination type, where the destination type is an LLVM scalar type.
3850  QualType SrcTy,
3851  QualType DstTy,
3852  SourceLocation Loc) {
3853  assert(SrcTy->isAnyComplexType() && hasScalarEvaluationKind(DstTy) &&
3854  "Invalid complex -> scalar conversion");
3855  return ScalarExprEmitter(*this)
3856  .EmitComplexToScalarConversion(Src, SrcTy, DstTy, Loc);
3857 }
3858 
3859 
3862  bool isInc, bool isPre) {
3863  return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre);
3864 }
3865 
3867  // object->isa or (*object).isa
3868  // Generate code as for: *(Class*)object
3869 
3870  Expr *BaseExpr = E->getBase();
3871  Address Addr = Address::invalid();
3872  if (BaseExpr->isRValue()) {
3873  Addr = Address(EmitScalarExpr(BaseExpr), getPointerAlign());
3874  } else {
3875  Addr = EmitLValue(BaseExpr).getAddress();
3876  }
3877 
3878  // Cast the address to Class*.
3879  Addr = Builder.CreateElementBitCast(Addr, ConvertType(E->getType()));
3880  return MakeAddrLValue(Addr, E->getType());
3881 }
3882 
3883 
3885  const CompoundAssignOperator *E) {
3886  ScalarExprEmitter Scalar(*this);
3887  Value *Result = nullptr;
3888  switch (E->getOpcode()) {
3889 #define COMPOUND_OP(Op) \
3890  case BO_##Op##Assign: \
3891  return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \
3892  Result)
3893  COMPOUND_OP(Mul);
3894  COMPOUND_OP(Div);
3895  COMPOUND_OP(Rem);
3896  COMPOUND_OP(Add);
3897  COMPOUND_OP(Sub);
3898  COMPOUND_OP(Shl);
3899  COMPOUND_OP(Shr);
3900  COMPOUND_OP(And);
3901  COMPOUND_OP(Xor);
3902  COMPOUND_OP(Or);
3903 #undef COMPOUND_OP
3904 
3905  case BO_PtrMemD:
3906  case BO_PtrMemI:
3907  case BO_Mul:
3908  case BO_Div:
3909  case BO_Rem:
3910  case BO_Add:
3911  case BO_Sub:
3912  case BO_Shl:
3913  case BO_Shr:
3914  case BO_LT:
3915  case BO_GT:
3916  case BO_LE:
3917  case BO_GE:
3918  case BO_EQ:
3919  case BO_NE:
3920  case BO_Cmp:
3921  case BO_And:
3922  case BO_Xor:
3923  case BO_Or:
3924  case BO_LAnd:
3925  case BO_LOr:
3926  case BO_Assign:
3927  case BO_Comma:
3928  llvm_unreachable("Not valid compound assignment operators");
3929  }
3930 
3931  llvm_unreachable("Unhandled compound assignment operator");
3932 }
3933 
3935  ArrayRef<Value *> IdxList,
3936  bool SignedIndices,
3937  bool IsSubtraction,
3938  SourceLocation Loc,
3939  const Twine &Name) {
3940  Value *GEPVal = Builder.CreateInBoundsGEP(Ptr, IdxList, Name);
3941 
3942  // If the pointer overflow sanitizer isn't enabled, do nothing.
3943  if (!SanOpts.has(SanitizerKind::PointerOverflow))
3944  return GEPVal;
3945 
3946  // If the GEP has already been reduced to a constant, leave it be.
3947  if (isa<llvm::Constant>(GEPVal))
3948  return GEPVal;
3949 
3950  // Only check for overflows in the default address space.
3951  if (GEPVal->getType()->getPointerAddressSpace())
3952  return GEPVal;
3953 
3954  auto *GEP = cast<llvm::GEPOperator>(GEPVal);
3955  assert(GEP->isInBounds() && "Expected inbounds GEP");
3956 
3957  SanitizerScope SanScope(this);
3958  auto &VMContext = getLLVMContext();
3959  const auto &DL = CGM.getDataLayout();
3960  auto *IntPtrTy = DL.getIntPtrType(GEP->getPointerOperandType());
3961 
3962  // Grab references to the signed add/mul overflow intrinsics for intptr_t.
3963  auto *Zero = llvm::ConstantInt::getNullValue(IntPtrTy);
3964  auto *SAddIntrinsic =
3965  CGM.getIntrinsic(llvm::Intrinsic::sadd_with_overflow, IntPtrTy);
3966  auto *SMulIntrinsic =
3967  CGM.getIntrinsic(llvm::Intrinsic::smul_with_overflow, IntPtrTy);
3968 
3969  // The total (signed) byte offset for the GEP.
3970  llvm::Value *TotalOffset = nullptr;
3971  // The offset overflow flag - true if the total offset overflows.
3972  llvm::Value *OffsetOverflows = Builder.getFalse();
3973 
3974  /// Return the result of the given binary operation.
3975  auto eval = [&](BinaryOperator::Opcode Opcode, llvm::Value *LHS,
3976  llvm::Value *RHS) -> llvm::Value * {
3977  assert((Opcode == BO_Add || Opcode == BO_Mul) && "Can't eval binop");
3978 
3979  // If the operands are constants, return a constant result.
3980  if (auto *LHSCI = dyn_cast<llvm::ConstantInt>(LHS)) {
3981  if (auto *RHSCI = dyn_cast<llvm::ConstantInt>(RHS)) {
3982  llvm::APInt N;
3983  bool HasOverflow = mayHaveIntegerOverflow(LHSCI, RHSCI, Opcode,
3984  /*Signed=*/true, N);
3985  if (HasOverflow)
3986  OffsetOverflows = Builder.getTrue();
3987  return llvm::ConstantInt::get(VMContext, N);
3988  }
3989  }
3990 
3991  // Otherwise, compute the result with checked arithmetic.
3992  auto *ResultAndOverflow = Builder.CreateCall(
3993  (Opcode == BO_Add) ? SAddIntrinsic : SMulIntrinsic, {LHS, RHS});
3994  OffsetOverflows = Builder.CreateOr(
3995  Builder.CreateExtractValue(ResultAndOverflow, 1), OffsetOverflows);
3996  return Builder.CreateExtractValue(ResultAndOverflow, 0);
3997  };
3998 
3999  // Determine the total byte offset by looking at each GEP operand.
4000  for (auto GTI = llvm::gep_type_begin(GEP), GTE = llvm::gep_type_end(GEP);
4001  GTI != GTE; ++GTI) {
4002  llvm::Value *LocalOffset;
4003  auto *Index = GTI.getOperand();
4004  // Compute the local offset contributed by this indexing step:
4005  if (auto *STy = GTI.getStructTypeOrNull()) {
4006  // For struct indexing, the local offset is the byte position of the
4007  // specified field.
4008  unsigned FieldNo = cast<llvm::ConstantInt>(Index)->getZExtValue();
4009  LocalOffset = llvm::ConstantInt::get(
4010  IntPtrTy, DL.getStructLayout(STy)->getElementOffset(FieldNo));
4011  } else {
4012  // Otherwise this is array-like indexing. The local offset is the index
4013  // multiplied by the element size.
4014  auto *ElementSize = llvm::ConstantInt::get(
4015  IntPtrTy, DL.getTypeAllocSize(GTI.getIndexedType()));
4016  auto *IndexS = Builder.CreateIntCast(Index, IntPtrTy, /*isSigned=*/true);
4017  LocalOffset = eval(BO_Mul, ElementSize, IndexS);
4018  }
4019 
4020  // If this is the first offset, set it as the total offset. Otherwise, add
4021  // the local offset into the running total.
4022  if (!TotalOffset || TotalOffset == Zero)
4023  TotalOffset = LocalOffset;
4024  else
4025  TotalOffset = eval(BO_Add, TotalOffset, LocalOffset);
4026  }
4027 
4028  // Common case: if the total offset is zero, don't emit a check.
4029  if (TotalOffset == Zero)
4030  return GEPVal;
4031 
4032  // Now that we've computed the total offset, add it to the base pointer (with
4033  // wrapping semantics).
4034  auto *IntPtr = Builder.CreatePtrToInt(GEP->getPointerOperand(), IntPtrTy);
4035  auto *ComputedGEP = Builder.CreateAdd(IntPtr, TotalOffset);
4036 
4037  // The GEP is valid if:
4038  // 1) The total offset doesn't overflow, and
4039  // 2) The sign of the difference between the computed address and the base
4040  // pointer matches the sign of the total offset.
4041  llvm::Value *ValidGEP;
4042  auto *NoOffsetOverflow = Builder.CreateNot(OffsetOverflows);
4043  if (SignedIndices) {
4044  auto *PosOrZeroValid = Builder.CreateICmpUGE(ComputedGEP, IntPtr);
4045  auto *PosOrZeroOffset = Builder.CreateICmpSGE(TotalOffset, Zero);
4046  llvm::Value *NegValid = Builder.CreateICmpULT(ComputedGEP, IntPtr);
4047  ValidGEP = Builder.CreateAnd(
4048  Builder.CreateSelect(PosOrZeroOffset, PosOrZeroValid, NegValid),
4049  NoOffsetOverflow);
4050  } else if (!SignedIndices && !IsSubtraction) {
4051  auto *PosOrZeroValid = Builder.CreateICmpUGE(ComputedGEP, IntPtr);
4052  ValidGEP = Builder.CreateAnd(PosOrZeroValid, NoOffsetOverflow);
4053  } else {
4054  auto *NegOrZeroValid = Builder.CreateICmpULE(ComputedGEP, IntPtr);
4055  ValidGEP = Builder.CreateAnd(NegOrZeroValid, NoOffsetOverflow);
4056  }
4057 
4058  llvm::Constant *StaticArgs[] = {EmitCheckSourceLocation(Loc)};
4059  // Pass the computed GEP to the runtime to avoid emitting poisoned arguments.
4060  llvm::Value *DynamicArgs[] = {IntPtr, ComputedGEP};
4061  EmitCheck(std::make_pair(ValidGEP, SanitizerKind::PointerOverflow),
4062  SanitizerHandler::PointerOverflow, StaticArgs, DynamicArgs);
4063 
4064  return GEPVal;
4065 }
const llvm::DataLayout & getDataLayout() const
llvm::Value * getArrayInitIndex()
Get the index of the current ArrayInitLoopExpr, if any.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Defines the clang::ASTContext interface.
std::pair< RValue, llvm::Value * > EmitAtomicCompareExchange(LValue Obj, RValue Expected, RValue Desired, SourceLocation Loc, llvm::AtomicOrdering Success=llvm::AtomicOrdering::SequentiallyConsistent, llvm::AtomicOrdering Failure=llvm::AtomicOrdering::SequentiallyConsistent, bool IsWeak=false, AggValueSlot Slot=AggValueSlot::ignored())
Emit a compare-and-exchange op for atomic type.
Definition: CGAtomic.cpp:1969
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:565
Expr * getChosenSubExpr() const
getChosenSubExpr - Return the subexpression chosen according to the condition.
Definition: Expr.h:3744
llvm::Value * EmitARCStoreStrong(LValue lvalue, llvm::Value *value, bool resultIgnored)
Store into a strong object.
Definition: CGObjC.cpp:2144
bool getValue() const
Definition: ExprObjC.h:94
bool getValue() const
Definition: ExprCXX.h:2385
llvm::Value * EmitARCReclaimReturnedObject(const Expr *e, bool allowUnsafeClaim)
Definition: CGObjC.cpp:2580
static BinOpInfo createBinOpInfoFromIncDec(const UnaryOperator *E, llvm::Value *InVal, bool IsInc)
VersionTuple getPlatformMinVersion() const
Retrieve the minimum desired version of the platform, to which the program should be compiled...
Definition: TargetInfo.h:1059
LValue getReferenceLValue(CodeGenFunction &CGF, Expr *refExpr) const
bool isSignedOverflowDefined() const
Definition: LangOptions.h:228
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2374
QualType getPointeeType() const
Definition: Type.h:2387
A (possibly-)qualified type.
Definition: Type.h:654
uint64_t getValue() const
Definition: ExprCXX.h:2475
bool sanitizePerformTypeCheck() const
Whether any type-checking sanitizers are enabled.
Definition: CGExpr.cpp:609
llvm::Type * ConvertTypeForMem(QualType T)
void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock, uint64_t TrueCount)
EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g.
static Opcode getOpForCompoundAssignment(Opcode Opc)
Definition: Expr.h:3158
const CodeGenOptions & getCodeGenOpts() const
llvm::Value * EmitARCExtendBlockObject(const Expr *expr)
Definition: CGObjC.cpp:2999
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
Definition: Type.cpp:1863
RValue EmitCoyieldExpr(const CoyieldExpr &E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
llvm::Constant * EmitCheckTypeDescriptor(QualType T)
Emit a description of a type in a format suitable for passing to a runtime sanitizer handler...
Definition: CGExpr.cpp:2664
Expr * getExpr(unsigned Index)
getExpr - Return the Expr at the specified index.
Definition: Expr.h:3612
unsigned getNumSubExprs() const
getNumSubExprs - Return the size of the SubExprs array.
Definition: Expr.h:3606
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
Definition: ExprCXX.h:2342
llvm::Constant * getMemberPointerConstant(const UnaryOperator *e)
CompoundStmt * getSubStmt()
Definition: Expr.h:3543
LValue EmitObjCIsaExpr(const ObjCIsaExpr *E)
const Expr * getInit(unsigned Init) const
Definition: Expr.h:3959
static llvm::Constant * getAsInt32(llvm::ConstantInt *C, llvm::Type *I32Ty)
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
Stmt - This represents one statement.
Definition: Stmt.h:66
Kind getKind() const
Definition: Type.h:2255
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:460
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:223
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1900
Address GetAddressOfDerivedClass(Address Value, const CXXRecordDecl *Derived, CastExpr::path_const_iterator PathBegin, CastExpr::path_const_iterator PathEnd, bool NullCheckValue)
Definition: CGClass.cpp:374
Address EmitPointerWithAlignment(const Expr *Addr, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
EmitPointerWithAlignment - Given an expression with a pointer type, emit the value and compute our be...
Definition: CGExpr.cpp:992
Address EmitVAArg(VAArgExpr *VE, Address &VAListAddr)
Generate code to get an argument from the passed in pointer and update it accordingly.
Definition: CGCall.cpp:4505
Expr * getBase() const
Definition: Expr.h:2514
RValue EmitPseudoObjectRValue(const PseudoObjectExpr *e, AggValueSlot slot=AggValueSlot::ignored())
Definition: CGExpr.cpp:4855
llvm::APFloat getValue() const
Definition: Expr.h:1421
void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, llvm::Value *V, QualType Type, CharUnits Alignment=CharUnits::Zero(), SanitizerSet SkippedChecks=SanitizerSet())
Emit a check that V is the address of storage of the appropriate size and alignment for an object of ...
Definition: CGExpr.cpp:616
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Definition: Expr.h:4584
bool isExtVectorType() const
Definition: Type.h:6137
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
Definition: DeclCXX.h:245
RValue EmitCoawaitExpr(const CoawaitExpr &E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
Opcode getOpcode() const
Definition: Expr.h:3065
void EmitCheck(ArrayRef< std::pair< llvm::Value *, SanitizerMask >> Checked, SanitizerHandler Check, ArrayRef< llvm::Constant *> StaticArgs, ArrayRef< llvm::Value *> DynamicArgs)
Create a basic block that will call a handler function in a sanitizer runtime with the provided argum...
Definition: CGExpr.cpp:2876
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1689
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:5997
llvm::Value * LoadCXXThis()
LoadCXXThis - Load the value of &#39;this&#39;.
void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false)
EmitStoreThroughLValue - Store the specified rvalue into the specified lvalue, where both are guarant...
Definition: CGExpr.cpp:1865
FPOptions getFPFeatures() const
Definition: Expr.h:3196
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent...
Definition: ExprCXX.h:2426
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:672
Floating point control options.
Definition: LangOptions.h:263
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:4039
const Expr * getResultExpr() const
The generic selection&#39;s result expression.
Definition: Expr.h:4799
static Value * buildFMulAdd(llvm::BinaryOperator *MulOp, Value *Addend, const CodeGenFunction &CGF, CGBuilderTy &Builder, bool negMul, bool negAdd)
bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result, bool AllowLabels=false)
ConstantFoldsToSimpleInteger - If the specified expression does not fold to a constant, or if it does but contains a label, return false.
QualType getElementType() const
Definition: Type.h:2684
#define COMPOUND_OP(Op)
Expr * getIndexExpr(unsigned Idx)
Definition: Expr.h:2022
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
Definition: Type.cpp:1847
bool EvaluateAsInt(llvm::APSInt &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer...
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC &#39;id&#39; type.
Definition: ExprObjC.h:1436
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:2674
RAII object to set/unset CodeGenFunction::IsSanitizerScope.
const AstTypeMatcher< PointerType > pointerType
Matches pointer types, but does not match Objective-C object pointer types.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6455
uint64_t getProfileCount(const Stmt *S)
Get the profiler&#39;s count for the given statement.
const llvm::fltSemantics & getHalfFormat() const
Definition: TargetInfo.h:447
llvm::Value * EmitBlockCopyAndAutorelease(llvm::Value *Block, QualType Ty)
Definition: CGObjC.cpp:3396
void EmitVariablyModifiedType(QualType Ty)
EmitVLASize - Capture all the sizes for the VLA expressions in the given variably-modified type and s...
llvm::Value * getPointer() const
Definition: Address.h:38
bool IsSanitizerScope
True if CodeGen currently emits code implementing sanitizer checks.
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:985
Represents an expression – generally a full-expression – that introduces cleanups to be run at the ...
Definition: ExprCXX.h:3003
llvm::Value * EmitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E)
Definition: CGObjC.cpp:243
void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, llvm::Value **Result=nullptr)
EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints as EmitStoreThroughLValue.
Definition: CGExpr.cpp:1962
Expr * IgnoreImpCasts() LLVM_READONLY
IgnoreImpCasts - Skip past any implicit casts which might surround this expression.
Definition: Expr.h:2904
void EmitBoundsCheck(const Expr *E, const Expr *Base, llvm::Value *Index, QualType IndexType, bool Accessed)
Emit a check that Base points into an array object, which we can access at index Index.
Definition: CGExpr.cpp:915
Represents a struct/union/class.
Definition: Decl.h:3548
const TargetInfo & getTarget() const
An object to manage conditionally-evaluated expressions.
llvm::Value * EmitCXXNewExpr(const CXXNewExpr *E)
Definition: CGExprCXX.cpp:1540
FieldDecl * getField() const
For a field offsetof node, returns the field.
Definition: Expr.h:1919
llvm::Value * EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, bool isInc, bool isPre)
LValue EmitScalarCompoundAssignWithComplex(const CompoundAssignOperator *E, llvm::Value *&Result)
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
Definition: Expr.h:3572
Address getAddress() const
Definition: CGValue.h:327
QualType getComputationResultType() const
Definition: Expr.h:3256
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:150
std::pair< LValue, llvm::Value * > EmitARCStoreAutoreleasing(const BinaryOperator *e)
Definition: CGObjC.cpp:3155
llvm::Value * EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE)
Definition: CGExprCXX.cpp:2151
bool isVolatileQualified() const
Definition: CGValue.h:258
Represents a member of a struct/union/class.
Definition: Decl.h:2521
An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
unsigned getArrayExprIndex() const
For an array element node, returns the index into the array of expressions.
Definition: Expr.h:1913
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
Definition: Expr.h:3783
bool isReferenceType() const
Definition: Type.h:6060
Expr * getSubExpr()
Definition: Expr.h:2800
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp, [NSNumber numberWithInt:42]];.
Definition: ExprObjC.h:171
llvm::Value * EmitObjCBoxedExpr(const ObjCBoxedExpr *E)
EmitObjCBoxedExpr - This routine generates code to call the appropriate expression boxing method...
Definition: CGObjC.cpp:60
bool hadArrayRangeDesignator() const
Definition: Expr.h:4079
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:110
bool isGLValue() const
Definition: Expr.h:252
Describes an C or C++ initializer list.
Definition: Expr.h:3911
BinaryOperatorKind
llvm::Value * EmitObjCStringLiteral(const ObjCStringLiteral *E)
Emits an instance of NSConstantString representing the object.
Definition: CGObjC.cpp:46
Address CreateElementBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Cast the element type of the given address to a different type, preserving information like the align...
Definition: CGBuilder.h:157
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
APValue Val
Val - This is the value the expression can be folded to.
Definition: Expr.h:573
uint32_t Offset
Definition: CacheTokens.cpp:43
bool isOne() const
isOne - Test whether the quantity equals one.
Definition: CharUnits.h:119
path_iterator path_begin()
Definition: Expr.h:2816
llvm::Value * EmitBlockLiteral(const BlockExpr *)
Emit block literal.
Definition: CGBlocks.cpp:735
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3024
virtual llvm::Value * EmitMemberPointerIsNotNull(CodeGenFunction &CGF, llvm::Value *MemPtr, const MemberPointerType *MPT)
Determine if a member pointer is non-null. Returns an i1.
Definition: CGCXXABI.cpp:97
static Value * tryEmitFMulAdd(const BinOpInfo &op, const CodeGenFunction &CGF, CGBuilderTy &Builder, bool isSub=false)
ObjCStringLiteral, used for Objective-C string literals i.e.
Definition: ExprObjC.h:51
static llvm::Constant * getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx, unsigned Off, llvm::Type *I32Ty)
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5824
field_iterator field_begin() const
Definition: Decl.cpp:4027
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
llvm::Value * EmitARCRetainScalarExpr(const Expr *expr)
EmitARCRetainScalarExpr - Semantically equivalent to EmitARCRetainObject(e->getType(), EmitScalarExpr(e)), but making a best-effort attempt to peephole expressions that naturally produce retained objects.
Definition: CGObjC.cpp:2966
void EmitIgnoredExpr(const Expr *E)
EmitIgnoredExpr - Emit an expression in a context which ignores the result.
Definition: CGExpr.cpp:182
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2747
Helper class for OffsetOfExpr.
Definition: Expr.h:1855
void ForceCleanup(std::initializer_list< llvm::Value **> ValuesToReload={})
Force the emission of cleanups now, instead of waiting until this object is destroyed.
RValue EmitAtomicExpr(AtomicExpr *E)
Definition: CGAtomic.cpp:745
static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts=false)
ContainsLabel - Return true if the statement contains a label in it.
void incrementProfileCounter(const Stmt *S, llvm::Value *StepV=nullptr)
Increment the profiler&#39;s counter for the given statement by StepV.
uint64_t getCurrentProfileCount()
Get the profiler&#39;s current count.
QualType getReturnType() const
Definition: DeclObjC.h:361
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:1042
static bool ShouldNullCheckClassCastValue(const CastExpr *Cast)
Checking the operand of a load. Must be suitably sized and aligned.
This object can be modified without requiring retains or releases.
Definition: Type.h:174
Represents the this expression in C++.
Definition: ExprCXX.h:945
virtual llvm::Value * performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, llvm::Value *V, LangAS SrcAddr, LangAS DestAddr, llvm::Type *DestTy, bool IsNonNull=false) const
Perform address space cast of an expression of pointer type.
Definition: TargetInfo.cpp:447
llvm::Constant * CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false)
Create a new runtime function with the specified type and name.
static bool isNullPointerArithmeticExtension(ASTContext &Ctx, Opcode Opc, Expr *LHS, Expr *RHS)
Definition: Expr.cpp:1835
const Expr * getExpr() const
Get the initialization expression that will be used.
Definition: ExprCXX.h:1141
#define HANDLEBINOP(OP)
llvm::Value * EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty, SourceLocation Loc, AlignmentSource Source=AlignmentSource::Type, bool isNontemporal=false)
EmitLoadOfScalar - Load a scalar value from an address, taking care to appropriately convert from the...
bool isHalfType() const
Definition: Type.h:6281
RValue EmitObjCMessageExpr(const ObjCMessageExpr *E, ReturnValueSlot Return=ReturnValueSlot())
Definition: CGObjC.cpp:355
bool isValid() const
Definition: Address.h:36
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:276
bool isPromotableIntegerType() const
More type predicates useful for type checking/promotion.
Definition: Type.cpp:2417
static CharUnits One()
One - Construct a CharUnits quantity of one.
Definition: CharUnits.h:58
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Definition: ExprCXX.h:2200
std::pair< llvm::Value *, llvm::Value * > ComplexPairTy
llvm::CallInst * EmitNounwindRuntimeCall(llvm::Value *callee, const Twine &name="")
const TargetCodeGenInfo & getTargetCodeGenInfo()
QualType getComputationLHSType() const
Definition: Expr.h:3253
CastKind
CastKind - The kind of operation required for a conversion.
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand...
Definition: Expr.h:2064
llvm::Constant * getNullPointer(llvm::PointerType *T, QualType QT)
Get target specific null pointer.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
Represents a call to the builtin function __builtin_va_arg.
Definition: Expr.h:3817
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:39
const llvm::fltSemantics & getLongDoubleFormat() const
Definition: TargetInfo.h:463
unsigned getValue() const
Definition: Expr.h:1388
llvm::Value * EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored)
i8* @objc_storeWeak(i8** addr, i8* value) Returns value.
Definition: CGObjC.cpp:2250
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
Definition: Expr.h:4958
llvm::APSInt getShuffleMaskIdx(const ASTContext &Ctx, unsigned N) const
Definition: Expr.h:3623
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type...
Definition: ExprCXX.h:1805
bool isEventT() const
Definition: Type.h:6206
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:636
Expr - This represents one expression.
Definition: Expr.h:106
Allow any unmodeled side effect.
Definition: Expr.h:598
static Address invalid()
Definition: Address.h:35
CXXBaseSpecifier * getBase() const
For a base class node, returns the base specifier.
Definition: Expr.h:1929
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
const FunctionProtoType * T
llvm::Value * EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy, QualType DstTy, SourceLocation Loc)
Emit a conversion from the specified complex type to the specified destination type, where the destination type is an LLVM scalar type.
SourceLocation getExprLoc() const LLVM_READONLY
Definition: ExprObjC.h:1485
const CXXRecordDecl * getPointeeCXXRecordDecl() const
If this is a pointer or reference to a RecordType, return the CXXRecordDecl that the type refers to...
Definition: Type.cpp:1575
unsigned getPackLength() const
Retrieve the length of the parameter pack.
Definition: ExprCXX.h:3804
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6518
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:4890
Address EmitCompoundStmt(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
EmitCompoundStmt - Emit a compound statement {..} node.
Definition: CGStmt.cpp:372
unsigned getNumInits() const
Definition: Expr.h:3941
bool isNullPtrType() const
Definition: Type.h:6294
void SetFPAccuracy(llvm::Value *Val, float Accuracy)
SetFPAccuracy - Set the minimum required accuracy of the given floating point operation, expressed as the maximum relative error in ulp.
Definition: CGExpr.cpp:4765
VlaSizePair getVLASize(const VariableArrayType *vla)
Returns an LLVM value that corresponds to the size, in non-variably-sized elements, of a variable length array type, plus that largest non-variably-sized element type.
field_iterator field_end() const
Definition: Decl.h:3767
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
Definition: ExprObjC.h:288
llvm::Value * EmitToMemory(llvm::Value *Value, QualType Ty)
EmitToMemory - Change a scalar value from its value representation to its in-memory representation...
Definition: CGExpr.cpp:1628
bool isAnyComplexType() const
Definition: Type.h:6129
ObjCSelectorExpr used for @selector in Objective-C.
Definition: ExprObjC.h:429
TypeSourceInfo * getTypeSourceInfo() const
Definition: Expr.h:2001
Represents an expression that computes the length of a parameter pack.
Definition: ExprCXX.h:3727
AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...
Definition: Expr.h:4935
unsigned getFieldCount() const
getFieldCount - Get the number of fields in the layout.
Definition: RecordLayout.h:177
Kind getKind() const
Determine what kind of offsetof node this is.
Definition: Expr.h:1909
QualType getType() const
Definition: Expr.h:128
void EmitNullabilityCheck(LValue LHS, llvm::Value *RHS, SourceLocation Loc)
Given an assignment *LHS = RHS, emit a test that checks if RHS is nonnull, if LHS is marked _Nonnull...
Definition: CGDecl.cpp:717
An RAII object to record that we&#39;re evaluating a statement expression.
QualType getTypeOfArgument() const
Gets the argument type, or the type of the argument expression, whichever is appropriate.
Definition: Expr.h:2127
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:903
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1741
Represents a GCC generic vector type.
Definition: Type.h:3005
bool isNullPointer() const
Definition: APValue.cpp:631
llvm::Value * EmitCastToVoidPtr(llvm::Value *value)
Emit a cast to void* in the appropriate address space.
Definition: CGExpr.cpp:50
ConstantEmission tryEmitAsConstant(DeclRefExpr *refExpr)
Try to emit a reference to the given value without producing it as an l-value.
Definition: CGExpr.cpp:1380
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:3841
const OffsetOfNode & getComponent(unsigned Idx) const
Definition: Expr.h:2008
const TargetInfo & getTarget() const
const Expr * getSubExpr() const
Definition: Expr.h:1705
bool getValue() const
Definition: ExprCXX.h:543
The l-value was considered opaque, so the alignment was determined from a type.
RecordDecl * getDecl() const
Definition: Type.h:4081
void EmitAlignmentAssumption(llvm::Value *PtrValue, unsigned Alignment, llvm::Value *OffsetValue=nullptr)
virtual bool useFP16ConversionIntrinsics() const
Check whether llvm intrinsics such as llvm.convert.to.fp16 should be used to convert to and from __fp...
Definition: TargetInfo.h:607
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
Definition: RecordLayout.h:181
There is no lifetime qualification on this type.
Definition: Type.h:170
bool getValue() const
Definition: ExprCXX.h:3628
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition: ExprCXX.h:338
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:875
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:142
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Definition: Expr.h:3640
virtual llvm::Value * EmitMemberPointerConversion(CodeGenFunction &CGF, const CastExpr *E, llvm::Value *Src)
Perform a derived-to-base, base-to-derived, or bitcast member pointer conversion. ...
Definition: CGCXXABI.cpp:74
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:181
Kind
A field in a dependent type, known only by its name.
Definition: Expr.h:1864
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:5008
Encodes a location in the source.
void EnsureInsertPoint()
EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go...
llvm::Value * EmitObjCArrayLiteral(const ObjCArrayLiteral *E)
Definition: CGObjC.cpp:239
std::pair< LValue, llvm::Value * > EmitARCStoreUnsafeUnretained(const BinaryOperator *e, bool ignored)
Definition: CGObjC.cpp:3105
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:5940
bool allowFPContractAcrossStatement() const
Definition: LangOptions.h:278
unsigned getOpenMPDefaultSimdAlign(QualType T) const
Get default simd alignment of the specified complete type in bits.
Expr * getSubExpr() const
Definition: Expr.h:1768
llvm::Value * EvaluateExprAsBool(const Expr *E)
EvaluateExprAsBool - Perform the usual unary conversions on the specified expression and compare the ...
Definition: CGExpr.cpp:164
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.h:1839
LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK)
Same as EmitLValue but additionally we generate checking code to guard against undefined behavior...
Definition: CGExpr.cpp:1163
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:1945
llvm::Value * EmitFromMemory(llvm::Value *Value, QualType Ty)
EmitFromMemory - Change a scalar value from its memory representation to its value representation...
Definition: CGExpr.cpp:1642
CastKind getCastKind() const
Definition: Expr.h:2794
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
Definition: ExprCXX.h:1845
QualType getElementType() const
Definition: Type.h:3040
A scoped helper to set the current debug location to the specified location or preferred location of ...
Definition: CGDebugInfo.h:641
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:186
bool canOverflow() const
Returns true if the unary operator can cause an overflow.
Definition: Expr.h:1781
CanQualType FloatTy
Definition: ASTContext.h:1009
SanitizerSet SanOpts
Sanitizers enabled for this function.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
Definition: Type.cpp:1823
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load, __atomic_store, and __atomic_compare_exchange_*, for the similarly-named C++11 instructions, and __c11 variants for <stdatomic.h>, and corresponding __opencl_atomic_* for OpenCL 2.0.
Definition: Expr.h:5142
UnaryExprOrTypeTrait getKind() const
Definition: Expr.h:2095
ObjCProtocolExpr used for protocol expression in Objective-C.
Definition: ExprObjC.h:474
TypeCheckKind
Situations in which we might emit a check for the suitability of a pointer or glvalue.
An aligned address.
Definition: Address.h:25
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2861
Address EmitArrayToPointerDecay(const Expr *Array, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
Definition: CGExpr.cpp:3179
An expression trait intrinsic.
Definition: ExprCXX.h:2496
const ObjCMethodDecl * getMethodDecl() const
Definition: ExprObjC.h:1302
bool isVectorType() const
Definition: Type.h:6133
Assigning into this object requires a lifetime extension.
Definition: Type.h:187
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:3527
ObjCBoxedExpr - used for generalized expression boxing.
Definition: ExprObjC.h:117
virtual llvm::Constant * EmitNullMemberPointer(const MemberPointerType *MPT)
Create a null member pointer of the given type.
Definition: CGCXXABI.cpp:105
bool isArgumentType() const
Definition: Expr.h:2100
RValue EmitCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue=ReturnValueSlot())
Definition: CGExpr.cpp:4275
bool isCanonical() const
Definition: Type.h:5868
void enterFullExpression(const ExprWithCleanups *E)
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2244
static Value * createCastsForTypeOfSameSize(CGBuilderTy &Builder, const llvm::DataLayout &DL, Value *Src, llvm::Type *DstTy, StringRef Name="")
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat &#39;semantics&#39; for the specified scalar floating point type.
Expr * getLHS() const
Definition: Expr.h:3068
CompoundAssignOperator - For compound assignments (e.g.
Definition: Expr.h:3230
const llvm::fltSemantics & getFloat128Format() const
Definition: TargetInfo.h:471
Represents a C11 generic selection.
Definition: Expr.h:4723
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type, returning the result.
virtual llvm::Value * EmitMemberPointerComparison(CodeGenFunction &CGF, llvm::Value *L, llvm::Value *R, const MemberPointerType *MPT, bool Inequality)
Emit a comparison between two member pointers. Returns an i1.
Definition: CGCXXABI.cpp:87
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:3483
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
Definition: CGValue.h:59
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.h:913
Dataflow Directional Tag Classes.
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i...
void EmitVTablePtrCheckForCast(QualType T, llvm::Value *Derived, bool MayBeNull, CFITypeCheckKind TCK, SourceLocation Loc)
Derived is the presumed address of an object of type T after a cast.
Definition: CGClass.cpp:2616
std::string OverflowHandler
The name of the handler function to be called when -ftrapv is specified.
Definition: LangOptions.h:173
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:571
Represents a delete expression for memory deallocation and destructor calls, e.g. ...
Definition: ExprCXX.h:2074
bool isShiftOp() const
Definition: Expr.h:3103
LValue getOrCreateOpaqueLValueMapping(const OpaqueValueExpr *e)
Given an opaque value expression, return its LValue mapping if it exists, otherwise create one...
Definition: CGExpr.cpp:4224
A runtime availability query.
Definition: ExprObjC.h:1633
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:70
Represents a &#39;co_yield&#39; expression.
Definition: ExprCXX.h:4391
static llvm::Intrinsic::ID GetIntrinsic(IntrinsicType IT, BuiltinType::Kind ElemKind)
static Value * emitPointerArithmetic(CodeGenFunction &CGF, const BinOpInfo &op, bool isSubtraction)
Emit pointer + index arithmetic.
bool isBooleanType() const
Definition: Type.h:6382
const Expr * getExpr() const
Definition: ExprCXX.h:1077
llvm::Constant * EmitNullConstant(QualType T)
Return the result of value-initializing the given type, i.e.
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5587
Checking the destination of a store. Must be suitably sized and aligned.
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type *> Tys=None)
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2593
bool isBitField() const
Definition: CGValue.h:254
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:108
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
Definition: Expr.cpp:1308
ExplicitCastExpr - An explicit cast written in the source code.
Definition: Expr.h:2927
static Value * ConvertVec3AndVec4(CGBuilderTy &Builder, CodeGenFunction &CGF, Value *Src, unsigned NumElementsDst)
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Definition: DeclBase.h:1606
llvm::APInt getValue() const
Definition: Expr.h:1295
LabelDecl * getLabel() const
Definition: Expr.h:3505
#define VISITCOMP(CODE, UI, SI, FP)
Represents a pointer to an Objective C object.
Definition: Type.h:5546
path_iterator path_end()
Definition: Expr.h:2817
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Definition: ExprCXX.h:3603
uint64_t SanitizerMask
Definition: Sanitizers.h:26
unsigned getIntWidth(QualType T) const
void EmitExplicitCastExprType(const ExplicitCastExpr *E, CodeGenFunction *CGF=nullptr)
Emit type info if type of an expression is a variably modified type.
Definition: CGExpr.cpp:976
bool HasSideEffects
Whether the evaluated expression has side effects.
Definition: Expr.h:544
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4071
Complex values, per C99 6.2.5p11.
Definition: Type.h:2314
Expr * getBase() const
Definition: ExprObjC.h:1462
void dump() const
Dumps the specified AST fragment and all subtrees to llvm::errs().
Definition: ASTDumper.cpp:2778
Checking the operand of a static_cast to a derived pointer type.
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2154
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
Definition: Expr.h:3266
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6303
T * getAttr() const
Definition: DeclBase.h:532
An implicit indirection through a C++ base class, when the field found is in a base class...
Definition: Expr.h:1867
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Definition: ASTContext.h:2041
bool isFunctionType() const
Definition: Type.h:6044
llvm::Value * EmitCheckedInBoundsGEP(llvm::Value *Ptr, ArrayRef< llvm::Value *> IdxList, bool SignedIndices, bool IsSubtraction, SourceLocation Loc, const Twine &Name="")
Same as IRBuilder::CreateInBoundsGEP, but additionally emits a check to detect undefined behavior whe...
Represents a &#39;co_await&#39; expression.
Definition: ExprCXX.h:4308
ExtVectorType - Extended vector type.
Definition: Type.h:3079
Opcode getOpcode() const
Definition: Expr.h:1765
llvm::Value * createOpenCLIntToSamplerConversion(const Expr *E, CodeGenFunction &CGF)
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition: CGStmt.cpp:445
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.h:3061
ComplexPairTy EmitComplexExpr(const Expr *E, bool IgnoreReal=false, bool IgnoreImag=false)
EmitComplexExpr - Emit the computation of the specified expression of complex type, returning the result.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2037
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:513
SourceManager & getSourceManager()
Definition: ASTContext.h:644
llvm::ConstantInt * getSize(CharUnits numChars)
Emit the given number of characters as a value of type size_t.
RValue getOrCreateOpaqueRValueMapping(const OpaqueValueExpr *e)
Given an opaque value expression, return its RValue mapping if it exists, otherwise create one...
Definition: CGExpr.cpp:4238
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2204
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1113
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
Definition: Expr.h:3664
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
Reading or writing from this object requires a barrier call.
Definition: Type.h:184
bool isQueueT() const
Definition: Type.h:6214
static llvm::Value * EmitCompare(CGBuilderTy &Builder, CodeGenFunction &CGF, const BinaryOperator *E, llvm::Value *LHS, llvm::Value *RHS, CompareKind Kind, const char *NameSuffix="")
Definition: CGExprAgg.cpp:891
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2424
void ErrorUnsupported(const Stmt *S, const char *Type)
ErrorUnsupported - Print out an error that codegen doesn&#39;t support the specified stmt yet...
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g., it is an signed integer type or a vector.
Definition: Type.cpp:1837
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
bool isVoidType() const
Definition: Type.h:6275
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:3703
An index into an array.
Definition: Expr.h:1860
llvm::Type * ConvertType(QualType T)
bool hasIntegerRepresentation() const
Determine whether this type has an integer representation of some sort, e.g., it is an integer type o...
Definition: Type.cpp:1696
void EmitCXXDeleteExpr(const CXXDeleteExpr *E)
Definition: CGExprCXX.cpp:1983
LValue EmitLValue(const Expr *E)
EmitLValue - Emit code to compute a designator that specifies the location of the expression...
Definition: CGExpr.cpp:1199
void EmitTrapCheck(llvm::Value *Checked)
Create a basic block that will call the trap intrinsic, and emit a conditional branch to it...
Definition: CGExpr.cpp:3147
bool isRValue() const
Definition: Expr.h:250
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2234
RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)
EmitLoadOfLValue - Given an expression that represents a value lvalue, this method emits the address ...
Definition: CGExpr.cpp:1711
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
Definition: Sanitizers.h:52
#define fabs(__x)
Definition: tgmath.h:565
Defines the clang::TargetInfo interface.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2242
LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E)
llvm::Value * EmitScalarConversion(llvm::Value *Src, QualType SrcTy, QualType DstTy, SourceLocation Loc)
Emit a conversion from the specified type to the specified destination type, both of which are LLVM s...
CGCXXABI & getCXXABI() const
const VariableArrayType * getAsVariableArrayType(QualType T) const
Definition: ASTContext.h:2354
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
Definition: ExprObjC.h:82
unsigned getNumComponents() const
Definition: Expr.h:2018
bool isEvaluatable(const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
isEvaluatable - Call EvaluateAsRValue to see if this expression can be constant folded without side-e...
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:972
static RValue get(llvm::Value *V)
Definition: CGValue.h:86
Expr * getRHS() const
Definition: Expr.h:3070
IntrinsicType
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
static ApplyDebugLocation CreateEmpty(CodeGenFunction &CGF)
Set the IRBuilder to not attach debug locations.
Definition: CGDebugInfo.h:689
llvm::Constant * EmitCheckSourceLocation(SourceLocation Loc)
Emit a description of a source location in a format suitable for passing to a runtime sanitizer handl...
Definition: CGExpr.cpp:2745
QualType getType() const
Definition: Decl.h:647
bool isFloatingType() const
Definition: Type.cpp:1884
LValue - This represents an lvalue references.
Definition: CGValue.h:167
llvm::BlockAddress * GetAddrOfLabel(const LabelDecl *L)
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:530
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type, member-designator).
Definition: Expr.h:1959
llvm::Value * EmitObjCConsumeObject(QualType T, llvm::Value *Ptr)
Produce the code for a CK_ARCConsumeObject.
Definition: CGObjC.cpp:1791
CanQualType BoolTy
Definition: ASTContext.h:998
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2808
const LangOptions & getLangOpts() const
Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:164
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.cpp:278
static bool isCheapEnoughToEvaluateUnconditionally(const Expr *E, CodeGenFunction &CGF)
isCheapEnoughToEvaluateUnconditionally - Return true if the specified expression is cheap enough and ...
const LangOptions & getLangOpts() const
Definition: ASTContext.h:689
llvm::Value * getPointer() const
Definition: CGValue.h:323
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:4619
void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint=true)
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97
llvm::Value * EmitBuiltinAvailable(ArrayRef< llvm::Value *> Args)
Definition: CGObjC.cpp:3421
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2439
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> PL, ArrayRef< Expr *> IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
llvm::Value * EmitObjCSelectorExpr(const ObjCSelectorExpr *E)
Emit a selector.
Definition: CGObjC.cpp:249
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1071
bool isCompoundAssignmentOp() const
Definition: Expr.h:3155
llvm::Value * EmitObjCProtocolExpr(const ObjCProtocolExpr *E)
Definition: CGObjC.cpp:257
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:291