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