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