reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

gen/tools/clang/include/clang/Basic/arm_mve_builtin_cg.inc

   16   Address Val0 = EmitPointerWithAlignment(E->getArg(0));
   18   Value *Val2 = EmitScalarExpr(E->getArg(1));
   26   Address Val0 = EmitPointerWithAlignment(E->getArg(0));
   28   Value *Val2 = EmitScalarExpr(E->getArg(1));
   29   Value *Val3 = EmitScalarExpr(E->getArg(2));
  159   Value *Val0 = EmitScalarExpr(E->getArg(0));
  161   Value *Val2 = EmitScalarExpr(E->getArg(1));
  167   Value *Val0 = EmitScalarExpr(E->getArg(0));
  168   Value *Val1 = EmitScalarExpr(E->getArg(1));
  169   Address Val2 = EmitPointerWithAlignment(E->getArg(2));
  206   Value *Val0 = EmitScalarExpr(E->getArg(0));
  207   Value *Val1 = EmitScalarExpr(E->getArg(1));
  213   Value *Val0 = EmitScalarExpr(E->getArg(0));
  214   Value *Val1 = EmitScalarExpr(E->getArg(1));
  215   Value *Val2 = EmitScalarExpr(E->getArg(2));
  216   Address Val3 = EmitPointerWithAlignment(E->getArg(3));
  220   Value *Val7 = EmitScalarExpr(E->getArg(4));
  234   Value *Val0 = EmitScalarExpr(E->getArg(0));
  235   Value *Val1 = EmitScalarExpr(E->getArg(1));
  236   Value *Val2 = EmitScalarExpr(E->getArg(2));
  238   Value *Val4 = EmitScalarExpr(E->getArg(4));
  247   Address Val13 = EmitPointerWithAlignment(E->getArg(3));
  253   Value *Val0 = EmitScalarExpr(E->getArg(0));
  254   Value *Val1 = EmitScalarExpr(E->getArg(1));
  262   Address Val9 = EmitPointerWithAlignment(E->getArg(2));
  277   Value *Val0 = EmitScalarExpr(E->getArg(0));
  278   Value *Val1 = EmitScalarExpr(E->getArg(1));
  280   Value *Val3 = EmitScalarExpr(E->getArg(2));
  296   Value *Val0 = EmitScalarExpr(E->getArg(0));
  297   Value *Val1 = EmitScalarExpr(E->getArg(1));
  307   Value *Val0 = EmitScalarExpr(E->getArg(0));
  308   Value *Val1 = EmitScalarExpr(E->getArg(1));
  313   Value *Val0 = EmitScalarExpr(E->getArg(0));
  314   Value *Val1 = EmitScalarExpr(E->getArg(1));
  319   Value *Val0 = EmitScalarExpr(E->getArg(0));
  320   Value *Val1 = EmitScalarExpr(E->getArg(1));
  329   Value *Val0 = EmitScalarExpr(E->getArg(0));
  330   Value *Val1 = EmitScalarExpr(E->getArg(1));
  334   Value *Val0 = EmitScalarExpr(E->getArg(0));
  339   Value *Val5 = EmitScalarExpr(E->getArg(1));
  450   Value *Val0 = EmitScalarExpr(E->getArg(1));
  451   Value *Val1 = EmitScalarExpr(E->getArg(2));
  452   Value *Val2 = EmitScalarExpr(E->getArg(3));
  455   Value *Val5 = EmitScalarExpr(E->getArg(0));

tools/clang/include/clang/AST/ExprCXX.h

  625     return getArg(0)->getBeginLoc();

tools/clang/include/clang/ASTMatchers/ASTMatchers.h

 3708               *Node.getArg(N)->IgnoreParenImpCasts(), Finder, Builder));
 4022     if (ArgMatcher.matches(*(Node.getArg(ArgIndex)->IgnoreParenCasts()),

tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h

  519     return getOriginExpr()->getArg(Index);
  554     return getOriginExpr()->getArg(Index);
  697     return getOriginExpr()->getArg(Index);
  738     return getOriginExpr()->getArg(Index + 1);

tools/clang/lib/AST/Expr.cpp

 1533   if (begin.isInvalid() && getNumArgs() > 0 && getArg(0))
 1534     begin = getArg(0)->getBeginLoc();
 1542   if (end.isInvalid() && getNumArgs() > 0 && getArg(getNumArgs() - 1))
 1543     end = getArg(getNumArgs() - 1)->getEndLoc();
 2556           R2 = SourceRange(CE->getArg(0)->getBeginLoc(),
 2557                            CE->getArg(NumArgs - 1)->getEndLoc());
 3315   const Expr* Arg = getArg(0);

tools/clang/lib/AST/ExprCXX.cpp

   93     Result.LHS = BO->getArg(0);
   94     Result.RHS = BO->getArg(1);
  118     Result.LHS = BO->getArg(0);
  119     Result.RHS = BO->getArg(1);
  665       return SourceRange(getOperatorLoc(), getArg(0)->getEndLoc());
  668       return SourceRange(getArg(0)->getBeginLoc(), getOperatorLoc());
  670     return getArg(0)->getSourceRange();
  672     return SourceRange(getArg(0)->getBeginLoc(), getRParenLoc());
  674     return SourceRange(getArg(0)->getBeginLoc(), getRParenLoc());
  676     return SourceRange(getOperatorLoc(), getArg(0)->getEndLoc());
  678     return SourceRange(getArg(0)->getBeginLoc(), getArg(1)->getEndLoc());
  678     return SourceRange(getArg(0)->getBeginLoc(), getArg(1)->getEndLoc());

tools/clang/lib/AST/ExprConstant.cpp

 5983   if (!EvaluateInteger(E->getArg(0), ByteSize, Info))
 5987     EvaluateIgnoredValue(Info, E->getArg(I));
 6101   if (!EvaluatePointer(E->getArg(0), Pointer, Info))
 6104     EvaluateIgnoredValue(Info, E->getArg(I));
 7723   if (!EvaluateAsSizeT(Call->getArg(SizeArgNo), SizeOfElem))
 7733   if (!EvaluateAsSizeT(Call->getArg(NumArgNo), NumberOfElems))
 8140     return evaluateLValue(E->getArg(0), Result);
 8145     if (!evaluatePointer(E->getArg(0), Result))
 8150     if (!EvaluateInteger(E->getArg(1), Alignment, Info))
 8156       if (!EvaluateInteger(E->getArg(2), Offset, Info))
 8179         CCEDiag(E->getArg(0),
 8192            ? CCEDiag(E->getArg(0),
 8194            : CCEDiag(E->getArg(0),
 8206     return evaluatePointer(E->getArg(0), Result);
 8223     if (!Visit(E->getArg(0)))
 8226     if (!EvaluateInteger(E->getArg(1), Desired, Info))
 8234       if (!EvaluateInteger(E->getArg(2), N, Info))
 8249                CharTy, E->getArg(0)->getType()->getPointeeType()));
 8269                                                   E->getArg(1)->getType(),
 8336     if (!Visit(E->getArg(0)))
 8341     if (!EvaluatePointer(E->getArg(1), Src, Info))
 8345     if (!EvaluateInteger(E->getArg(2), N, Info))
 8362           << Val.getAsString(Info.Ctx, E->getArg(0)->getType());
10098   return EvaluateBuiltinClassifyType(E->getArg(0)->getType(), LangOpts);
10511         E->getArg(1)->EvaluateKnownConstInt(Info.Ctx).getZExtValue();
10515     if (tryEvaluateBuiltinObjectSize(E->getArg(0), Type, Info, Size))
10518     if (E->getArg(0)->HasSideEffects(Info.Ctx))
10547     if (!EvaluateInteger(E->getArg(0), Val, Info))
10560     if (!EvaluateInteger(E->getArg(0), Val, Info))
10571     if (!EvaluateInteger(E->getArg(0), Val, Info))
10580     const Expr *Arg = E->getArg(0);
10601     if (!EvaluateInteger(E->getArg(0), Val, Info))
10610     int Operand = E->getArg(0)->EvaluateKnownConstInt(Info.Ctx).getZExtValue();
10616     return Visit(E->getArg(0));
10622     if (!EvaluateInteger(E->getArg(0), Val, Info))
10631     if (!EvaluateFloat(E->getArg(5), Val, Info))
10640     return Visit(E->getArg(Arg));
10645     return EvaluateFloat(E->getArg(0), Val, Info) &&
10651     return EvaluateFloat(E->getArg(0), Val, Info) &&
10657     return EvaluateFloat(E->getArg(0), Val, Info) &&
10663     return EvaluateFloat(E->getArg(0), Val, Info) &&
10669     return EvaluateFloat(E->getArg(0), Val, Info) &&
10677     if (!EvaluateInteger(E->getArg(0), Val, Info))
10687     if (!EvaluateInteger(E->getArg(0), Val, Info))
10708     if (!EvaluatePointer(E->getArg(0), String, Info))
10711     QualType CharTy = E->getArg(0)->getType()->getPointeeType();
10772     if (!EvaluatePointer(E->getArg(0), String1, Info) ||
10773         !EvaluatePointer(E->getArg(1), String2, Info))
10782       if (!EvaluateInteger(E->getArg(2), N, Info))
10806                 CharTy1, E->getArg(0)->getType()->getPointeeType()) &&
10907     if (!EvaluateInteger(E->getArg(0), SizeVal, Info))
10928             E->getArg(1)->isNullPointerConstant(Info.Ctx,
10934         QualType PointeeType = E->getArg(1)->IgnoreImpCasts()->getType()->
10974     QualType ResultType = E->getArg(2)->getType()->getPointeeType();
10975     if (!EvaluateInteger(E->getArg(0), LHS, Info) ||
10976         !EvaluateInteger(E->getArg(1), RHS, Info) ||
10977         !EvaluatePointer(E->getArg(2), ResultLValue, Info))
12469     if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
12480     if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
12489     if (!EvaluateFloat(E->getArg(0), Result, Info))
12505     if (!EvaluateFloat(E->getArg(0), Result, Info) ||
12506         !EvaluateFloat(E->getArg(1), RHS, Info))

tools/clang/lib/AST/ItaniumMangle.cpp

 4173       mangleExpression(CE->getArg(i));

tools/clang/lib/AST/OSLog.cpp

  190     StringArg = E->getArg(0);
  196     StringArg = E->getArg(1);

tools/clang/lib/AST/StmtProfile.cpp

 1536       return Visit(S->getArg(0));
 1544       Visit(S->getArg(I));

tools/clang/lib/Analysis/Consumed.cpp

  626     InfoEntry Entry = findInfo(Call->getArg(Index));
  639           Call->getArg(Index)->getExprLoc(),
  748     copyInfo(Call->getArg(0), Call, CS_Consumed);
  818     ConsumedState CS = getInfo(Call->getArg(1));
  819     if (!handleCall(Call, Call->getArg(0), FunDecl))
  820       setInfo(Call->getArg(0), CS);
  827     handleCall(Call, Call->getArg(0), FunDecl);

tools/clang/lib/Analysis/ThreadSafety.cpp

 1432       return getTrylockCallExpr(CallExp->getArg(0), C, Negate);
 2057         const Expr *Target = OE->getArg(0);
 2058         const Expr *Source = OE->getArg(1);
 2068           checkPtAccess(OE->getArg(0), AK_Read);
 2073         const Expr *Obj = OE->getArg(0);

tools/clang/lib/Analysis/ThreadSafetyCommon.cpp

  170       AttrExp = OE->getArg(0);
  422       auto *E = translate(OCE->getArg(0), Ctx);

tools/clang/lib/CodeGen/CGBuiltin.cpp

  121   assert(E->getArg(0)->getType()->isPointerType());
  123                                   E->getArg(0)->getType()->getPointeeType()));
  124   assert(CGF.getContext().hasSameUnqualifiedType(T, E->getArg(1)->getType()));
  126   llvm::Value *DestPtr = CGF.EmitScalarExpr(E->getArg(0));
  136   Args[1] = CGF.EmitScalarExpr(E->getArg(1));
  146   Value *Val = CGF.EmitScalarExpr(E->getArg(0));
  147   Value *Address = CGF.EmitScalarExpr(E->getArg(1));
  150   Val = CGF.EmitToMemory(Val, E->getArg(0)->getType());
  153   LValue LV = CGF.MakeNaturalAlignAddrLValue(BC, E->getArg(0)->getType());
  160   Value *Address = CGF.EmitScalarExpr(E->getArg(0));
  182   assert(E->getArg(0)->getType()->isPointerType());
  184                                   E->getArg(0)->getType()->getPointeeType()));
  185   assert(CGF.getContext().hasSameUnqualifiedType(T, E->getArg(1)->getType()));
  187   llvm::Value *DestPtr = CGF.EmitScalarExpr(E->getArg(0));
  196   Args[1] = CGF.EmitScalarExpr(E->getArg(1));
  227   QualType T = ReturnBool ? E->getArg(1)->getType() : E->getType();
  228   llvm::Value *DestPtr = CGF.EmitScalarExpr(E->getArg(0));
  237   Args[1] = CGF.EmitScalarExpr(E->getArg(1));
  240   Args[2] = EmitToInt(CGF, CGF.EmitScalarExpr(E->getArg(2)), T, IntType);
  271   assert(E->getArg(0)->getType()->isPointerType());
  273       E->getType(), E->getArg(0)->getType()->getPointeeType()));
  275                                                  E->getArg(1)->getType()));
  277                                                  E->getArg(2)->getType()));
  279   auto *Destination = CGF.EmitScalarExpr(E->getArg(0));
  280   auto *Comparand = CGF.EmitScalarExpr(E->getArg(2));
  281   auto *Exchange = CGF.EmitScalarExpr(E->getArg(1));
  297   assert(E->getArg(0)->getType()->isPointerType());
  302                    CGF.EmitScalarExpr(E->getArg(0)),
  310   assert(E->getArg(0)->getType()->isPointerType());
  315                    CGF.EmitScalarExpr(E->getArg(0)),
  323   Value *Ptr = CGF.EmitScalarExpr(E->getArg(0));
  324   QualType ElTy = E->getArg(0)->getType()->getPointeeType();
  336   Value *Ptr = CGF.EmitScalarExpr(E->getArg(0));
  337   Value *Value = CGF.EmitScalarExpr(E->getArg(1));
  338   QualType ElTy = E->getArg(0)->getType()->getPointeeType();
  354   llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
  364   llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
  365   llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));
  375   llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
  376   llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));
  377   llvm::Value *Src2 = CGF.EmitScalarExpr(E->getArg(2));
  387   llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
  388   llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));
  399    llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
  716       CGF.getContext().getTypeSize(E->getArg(1)->getType()));
  745   Value *BitBase = CGF.EmitScalarExpr(E->getArg(0));
  746   Value *BitPos = CGF.EmitScalarExpr(E->getArg(1));
  864       CGF.EmitScalarExpr(E->getArg(0)), CGF.Int8PtrTy);
  916     Value *ArgValue = EmitScalarExpr(E->getArg(1));
  920       EmitScalarExpr(E->getArg(0))->getType()->getPointerElementType();
  939     Address IndexAddress = EmitPointerWithAlignment(E->getArg(0));
 1072     llvm::CallInst *CI = Builder.CreateCall(IA, EmitScalarExpr(E->getArg(0)));
 1230   Address BufAddr = EmitPointerWithAlignment(E.getArg(0));
 1517   llvm::Value *Src = EmitScalarExpr(E->getArg(0));
 1518   llvm::Value *ShiftAmt = EmitScalarExpr(E->getArg(1));
 1655       Value *Arg1 = EmitScalarExpr(E->getArg(0));
 1656       Value *Arg2 = EmitScalarExpr(E->getArg(1));
 1797                            ? EmitScalarExpr(E->getArg(0))
 1798                            : EmitVAListRef(E->getArg(0)).getPointer(),
 1801     Value *DstPtr = EmitVAListRef(E->getArg(0)).getPointer();
 1802     Value *SrcPtr = EmitVAListRef(E->getArg(1)).getPointer();
 1816     Value *ArgValue = EmitScalarExpr(E->getArg(0));
 1826     ComplexPairTy ComplexVal = EmitComplexExpr(E->getArg(0));
 1843     ComplexPairTy ComplexVal = EmitComplexExpr(E->getArg(0));
 1852     Value *Func = EmitScalarExpr(E->getArg(1)->IgnoreImpCasts());
 1853     CharUnits Arg0Align = EmitPointerWithAlignment(E->getArg(0)).getAlignment();
 1855     const Expr *Arg0 = E->getArg(0)->IgnoreImpCasts();
 1870       return RValue::get(EmitScalarExpr(E->getArg(0)));
 1876       return RValue::get(EmitScalarExpr(E->getArg(0)));
 1880     Value *Res = EmitScalarExpr(E->getArg(0));
 1891     ComplexPairTy ComplexVal = EmitComplexExpr(E->getArg(0));
 1899     Value *ArgValue = EmitScalarExpr(E->getArg(0));
 1919     Value *ArgValue = EmitCheckedArgForBuiltin(E->getArg(0), BCK_CTZPassedZero);
 1936     Value *ArgValue = EmitCheckedArgForBuiltin(E->getArg(0), BCK_CLZPassedZero);
 1953     Value *ArgValue = EmitScalarExpr(E->getArg(0));
 1974     Value *ArgValue = EmitScalarExpr(E->getArg(0));
 1990     Value *ArgValue = EmitScalarExpr(E->getArg(0));
 2008     Value *ArgValue = EmitScalarExpr(E->getArg(0));
 2024     return RValue::get(EmitScalarExpr(E->getArg(0)));
 2027     Value *ArgValue = EmitScalarExpr(E->getArg(0));
 2030     Value *ExpectedValue = EmitScalarExpr(E->getArg(1));
 2043     const Expr *Ptr = E->getArg(0);
 2046       (E->getNumArgs() > 2) ? EmitScalarExpr(E->getArg(2)) : nullptr;
 2048     Value *AlignmentValue = EmitScalarExpr(E->getArg(1));
 2061     if (E->getArg(0)->HasSideEffects(getContext()))
 2064     Value *ArgValue = EmitScalarExpr(E->getArg(0));
 2104     const Expr *Arg = E->getArg(0);
 2136         E->getArg(1)->EvaluateKnownConstInt(getContext()).getZExtValue();
 2142     return RValue::get(emitBuiltinObjectSize(E->getArg(0), Type, ResType,
 2146     Value *Locality, *RW, *Address = EmitScalarExpr(E->getArg(0));
 2148     RW = (E->getNumArgs() > 1) ? EmitScalarExpr(E->getArg(1)) :
 2150     Locality = (E->getNumArgs() > 2) ? EmitScalarExpr(E->getArg(2)) :
 2161     Value *Begin = EmitScalarExpr(E->getArg(0));
 2162     Value *End = EmitScalarExpr(E->getArg(1));
 2182     Value *Base = EmitScalarExpr(E->getArg(0));
 2183     Value *Exponent = EmitScalarExpr(E->getArg(1));
 2197     Value *LHS = EmitScalarExpr(E->getArg(0));
 2198     Value *RHS = EmitScalarExpr(E->getArg(1));
 2225     Value *V = EmitScalarExpr(E->getArg(0));
 2241     Value *V = EmitScalarExpr(E->getArg(0));
 2253     Value *Arg = EmitScalarExpr(E->getArg(0));
 2270     Value *V = EmitScalarExpr(E->getArg(0));
 2277                    getContext().getFloatTypeSemantics(E->getArg(0)->getType()));
 2298     Value *V = EmitScalarExpr(E->getArg(5));
 2299     llvm::Type *Ty = ConvertType(E->getArg(5)->getType());
 2306       Builder.CreatePHI(ConvertType(E->getArg(0)->getType()), 4,
 2313     Value *ZeroLiteral = EmitScalarExpr(E->getArg(4));
 2321     Value *NanLiteral = EmitScalarExpr(E->getArg(0));
 2332     Value *InfLiteral = EmitScalarExpr(E->getArg(1));
 2340         getContext().getFloatTypeSemantics(E->getArg(5)->getType()));
 2345       Builder.CreateSelect(IsNormal, EmitScalarExpr(E->getArg(2)),
 2346                            EmitScalarExpr(E->getArg(3)));
 2358     Value *Size = EmitScalarExpr(E->getArg(0));
 2372     Value *Size = EmitScalarExpr(E->getArg(0));
 2373     Value *AlignmentInBitsValue = EmitScalarExpr(E->getArg(1));
 2386     Address Dest = EmitPointerWithAlignment(E->getArg(0));
 2387     Value *SizeVal = EmitScalarExpr(E->getArg(1));
 2388     EmitNonNullArgCheck(RValue::get(Dest.getPointer()), E->getArg(0)->getType(),
 2389                         E->getArg(0)->getExprLoc(), FD, 0);
 2395     Address Dest = EmitPointerWithAlignment(E->getArg(0));
 2396     Address Src = EmitPointerWithAlignment(E->getArg(1));
 2397     Value *SizeVal = EmitScalarExpr(E->getArg(2));
 2398     EmitNonNullArgCheck(RValue::get(Dest.getPointer()), E->getArg(0)->getType(),
 2399                         E->getArg(0)->getExprLoc(), FD, 0);
 2400     EmitNonNullArgCheck(RValue::get(Src.getPointer()), E->getArg(1)->getType(),
 2401                         E->getArg(1)->getExprLoc(), FD, 1);
 2413     if (!E->getArg(2)->EvaluateAsInt(SizeResult, CGM.getContext()) ||
 2414         !E->getArg(3)->EvaluateAsInt(DstSizeResult, CGM.getContext()))
 2420     Address Dest = EmitPointerWithAlignment(E->getArg(0));
 2421     Address Src = EmitPointerWithAlignment(E->getArg(1));
 2428     Address DestAddr = EmitPointerWithAlignment(E->getArg(0));
 2429     Address SrcAddr = EmitPointerWithAlignment(E->getArg(1));
 2430     Value *SizeVal = EmitScalarExpr(E->getArg(2));
 2439     if (!E->getArg(2)->EvaluateAsInt(SizeResult, CGM.getContext()) ||
 2440         !E->getArg(3)->EvaluateAsInt(DstSizeResult, CGM.getContext()))
 2446     Address Dest = EmitPointerWithAlignment(E->getArg(0));
 2447     Address Src = EmitPointerWithAlignment(E->getArg(1));
 2455     Address Dest = EmitPointerWithAlignment(E->getArg(0));
 2456     Address Src = EmitPointerWithAlignment(E->getArg(1));
 2457     Value *SizeVal = EmitScalarExpr(E->getArg(2));
 2458     EmitNonNullArgCheck(RValue::get(Dest.getPointer()), E->getArg(0)->getType(),
 2459                         E->getArg(0)->getExprLoc(), FD, 0);
 2460     EmitNonNullArgCheck(RValue::get(Src.getPointer()), E->getArg(1)->getType(),
 2461                         E->getArg(1)->getExprLoc(), FD, 1);
 2467     Address Dest = EmitPointerWithAlignment(E->getArg(0));
 2468     Value *ByteVal = Builder.CreateTrunc(EmitScalarExpr(E->getArg(1)),
 2470     Value *SizeVal = EmitScalarExpr(E->getArg(2));
 2471     EmitNonNullArgCheck(RValue::get(Dest.getPointer()), E->getArg(0)->getType(),
 2472                         E->getArg(0)->getExprLoc(), FD, 0);
 2479     if (!E->getArg(2)->EvaluateAsInt(SizeResult, CGM.getContext()) ||
 2480         !E->getArg(3)->EvaluateAsInt(DstSizeResult, CGM.getContext()))
 2486     Address Dest = EmitPointerWithAlignment(E->getArg(0));
 2487     Value *ByteVal = Builder.CreateTrunc(EmitScalarExpr(E->getArg(1)),
 2501     Value *Dst = EmitScalarExpr(E->getArg(0));
 2502     Value *Src = EmitScalarExpr(E->getArg(1));
 2503     Value *Size = EmitScalarExpr(E->getArg(2));
 2566     Value *Depth = ConstantEmitter(*this).emitAbstract(E->getArg(0),
 2576     Value *Depth = ConstantEmitter(*this).emitAbstract(E->getArg(0),
 2582     Value *Address = EmitScalarExpr(E->getArg(0));
 2587     Value *Address = EmitScalarExpr(E->getArg(0));
 2602     Value *Address = EmitScalarExpr(E->getArg(0));
 2608     Value *Int = EmitScalarExpr(E->getArg(0));
 2609     Value *Ptr = EmitScalarExpr(E->getArg(1));
 2641     Value *Ptr = EmitScalarExpr(E->getArg(0));
 2656     Address Buf = EmitPointerWithAlignment(E->getArg(0));
 2676     Value *Buf = EmitScalarExpr(E->getArg(0));
 2691     const Expr *Arg = E->getArg(0);
 2840     Value *Ptr = EmitScalarExpr(E->getArg(0));
 2841     QualType ElTy = E->getArg(0)->getType()->getPointeeType();
 2876     Args.add(RValue::get(EmitScalarExpr(E->getArg(0))),
 2879       Args.add(RValue::get(EmitScalarExpr(E->getArg(1))),
 2895     QualType PtrTy = E->getArg(0)->IgnoreImpCasts()->getType();
 2899     Value *Ptr = EmitScalarExpr(E->getArg(0));
 2903     Value *Order = EmitScalarExpr(E->getArg(1));
 2978     QualType PtrTy = E->getArg(0)->IgnoreImpCasts()->getType();
 2982     Address Ptr = EmitPointerWithAlignment(E->getArg(0));
 2986     Value *Order = EmitScalarExpr(E->getArg(1));
 3044     Value *Order = EmitScalarExpr(E->getArg(0));
 3107         Builder.CreateZExt(EmitSignBit(*this, EmitScalarExpr(E->getArg(0))),
 3134     llvm::Value *AnnVal = EmitScalarExpr(E->getArg(0));
 3140     const Expr *AnnotationStrExpr = E->getArg(1)->IgnoreParenCasts();
 3173     llvm::Value *X = EmitScalarExpr(E->getArg(0));
 3174     llvm::Value *Y = EmitScalarExpr(E->getArg(1));
 3175     llvm::Value *Carryin = EmitScalarExpr(E->getArg(2));
 3176     Address CarryOutPtr = EmitPointerWithAlignment(E->getArg(3));
 3214     const clang::Expr *LeftArg = E->getArg(0);
 3215     const clang::Expr *RightArg = E->getArg(1);
 3216     const clang::Expr *ResultArg = E->getArg(2);
 3322     llvm::Value *X = EmitScalarExpr(E->getArg(0));
 3323     llvm::Value *Y = EmitScalarExpr(E->getArg(1));
 3324     Address SumOutPtr = EmitPointerWithAlignment(E->getArg(2));
 3370     return RValue::get(EmitLValue(E->getArg(0)).getPointer());
 3382     const CallExpr *Call = cast<CallExpr>(E->getArg(0));
 3383     const Expr *Chain = E->getArg(1);
 3403       Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)), IntPtrType);
 3405     llvm::Value *Exchange = EmitScalarExpr(E->getArg(1));
 3410       Builder.CreatePtrToInt(EmitScalarExpr(E->getArg(2)), IntType);
 3564     Value *Arg0 = EmitScalarExpr(E->getArg(0)),
 3565           *Arg1 = EmitScalarExpr(E->getArg(1));
 3567     Value *PacketSize = OpenCLRT.getPipeElemSize(E->getArg(0));
 3568     Value *PacketAlign = OpenCLRT.getPipeElemAlign(E->getArg(0));
 3597       Value *Arg2 = EmitScalarExpr(E->getArg(2)),
 3598             *Arg3 = EmitScalarExpr(E->getArg(3));
 3634     Value *Arg0 = EmitScalarExpr(E->getArg(0)),
 3635           *Arg1 = EmitScalarExpr(E->getArg(1));
 3638     Value *PacketSize = OpenCLRT.getPipeElemSize(E->getArg(0));
 3639     Value *PacketAlign = OpenCLRT.getPipeElemAlign(E->getArg(0));
 3675     Value *Arg0 = EmitScalarExpr(E->getArg(0)),
 3676           *Arg1 = EmitScalarExpr(E->getArg(1));
 3678     Value *PacketSize = OpenCLRT.getPipeElemSize(E->getArg(0));
 3679     Value *PacketAlign = OpenCLRT.getPipeElemAlign(E->getArg(0));
 3695     const auto *PipeTy = E->getArg(0)->getType()->castAs<PipeType>();
 3704     Value *Arg0 = EmitScalarExpr(E->getArg(0));
 3706     Value *PacketSize = OpenCLRT.getPipeElemSize(E->getArg(0));
 3707     Value *PacketAlign = OpenCLRT.getPipeElemAlign(E->getArg(0));
 3720     auto Arg0 = EmitScalarExpr(E->getArg(0));
 3750     llvm::Value *Queue = EmitScalarExpr(E->getArg(0));
 3751     llvm::Value *Flags = EmitScalarExpr(E->getArg(1));
 3752     LValue NDRangeL = EmitAggExprToLValue(E->getArg(2));
 3766           CGM.getOpenCLRuntime().emitOpenCLEnqueuedBlock(*this, E->getArg(3));
 3807             Builder.CreateZExtOrTrunc(EmitScalarExpr(E->getArg(I)), SizeTy);
 3815     if (E->getArg(3)->getType()->isBlockPointerType()) {
 3819           CGM.getOpenCLRuntime().emitOpenCLEnqueuedBlock(*this, E->getArg(3));
 3852           Builder.CreateZExtOrTrunc(EmitScalarExpr(E->getArg(3)), Int32Ty);
 3858       if (E->getArg(4)->isNullPointerConstant(
 3862         EventWaitList = E->getArg(4)->getType()->isArrayType()
 3863                         ? EmitArrayToPointerDecay(E->getArg(4)).getPointer()
 3864                         : EmitScalarExpr(E->getArg(4));
 3869       if (E->getArg(5)->isNullPointerConstant(
 3874             Builder.CreatePointerCast(EmitScalarExpr(E->getArg(5)), EventPtrTy);
 3878           CGM.getOpenCLRuntime().emitOpenCLEnqueuedBlock(*this, E->getArg(6));
 3929         CGM.getOpenCLRuntime().emitOpenCLEnqueuedBlock(*this, E->getArg(0));
 3943         CGM.getOpenCLRuntime().emitOpenCLEnqueuedBlock(*this, E->getArg(0));
 3957     LValue NDRangeL = EmitAggExprToLValue(E->getArg(0));
 3960         CGM.getOpenCLRuntime().emitOpenCLEnqueuedBlock(*this, E->getArg(1));
 3978     Value *Val = EmitScalarExpr(E->getArg(0));
 3979     Address Address = EmitPointerWithAlignment(E->getArg(1));
 3984     Address Address = EmitPointerWithAlignment(E->getArg(0));
 3989     Address Address = EmitPointerWithAlignment(E->getArg(0));
 4026     auto Arg0 = E->getArg(0);
 4036     auto Arg1 = EmitScalarExpr(E->getArg(1));
 4060     auto Arg0 = EmitScalarExpr(E->getArg(0));
 4064     auto Arg1 = E->getArg(1);
 4074     auto Arg2 = EmitScalarExpr(E->getArg(2));
 4084         EmitVAStartEnd(EmitMSVAListRef(E->getArg(0)).getPointer(),
 4094     Address DestAddr = EmitMSVAListRef(E->getArg(0));
 4095     Address SrcAddr = EmitMSVAListRef(E->getArg(1));
 4163         ArgValue = EmitScalarExpr(E->getArg(i));
 4168         bool IsConst = E->getArg(i)->isIntegerConstantExpr(Result,getContext());
 5204   const Expr *Arg = E->getArg(0);
 5242   const Expr *Arg = E->getArg(E->getNumArgs() - 1);
 5925     const Expr *SysRegStrExpr = E->getArg(0)->IgnoreParenCasts();
 5955   llvm::Value *ArgValue = CGF.EmitScalarExpr(E->getArg(1));
 6020     if (!E->getArg(0)->EvaluateAsInt(Result, CGM.getContext()))
 6036     Value *Option = EmitScalarExpr(E->getArg(0));
 6041     Value *Address = EmitScalarExpr(E->getArg(0));
 6042     Value *RW      = EmitScalarExpr(E->getArg(1));
 6043     Value *IsData  = EmitScalarExpr(E->getArg(2));
 6053     llvm::Value *Arg = EmitScalarExpr(E->getArg(0));
 6059     llvm::Value *Arg = EmitScalarExpr(E->getArg(0));
 6063     llvm::Value *Arg = EmitScalarExpr(E->getArg(0));
 6073       Ops[i] = EmitScalarExpr(E->getArg(i));
 6101     Value *Coproc = EmitScalarExpr(E->getArg(0));
 6102     Value *Opc1 = EmitScalarExpr(E->getArg(1));
 6103     Value *RtAndRt2 = EmitScalarExpr(E->getArg(2));
 6104     Value *CRm = EmitScalarExpr(E->getArg(3));
 6128     Value *Coproc = EmitScalarExpr(E->getArg(0));
 6129     Value *Opc1 = EmitScalarExpr(E->getArg(1));
 6130     Value *CRm  = EmitScalarExpr(E->getArg(2));
 6167     Value *LdPtr = EmitScalarExpr(E->getArg(0));
 6184     Value *LoadAddr = EmitScalarExpr(E->getArg(0));
 6211        getContext().getTypeSize(E->getArg(0)->getType()) == 64)) {
 6217     Address Tmp = CreateMemTemp(E->getArg(0)->getType());
 6218     Value *Val = EmitScalarExpr(E->getArg(0));
 6226     Value *StPtr = Builder.CreateBitCast(EmitScalarExpr(E->getArg(1)), Int8PtrTy);
 6232     Value *StoreVal = EmitScalarExpr(E->getArg(0));
 6233     Value *StoreAddr = EmitScalarExpr(E->getArg(1));
 6235     QualType Ty = E->getArg(0)->getType();
 6282     Value *Arg0 = EmitScalarExpr(E->getArg(0));
 6283     Value *Arg1 = EmitScalarExpr(E->getArg(1));
 6383         PtrOp0 = EmitPointerWithAlignment(E->getArg(0));
 6410         PtrOp1 = EmitPointerWithAlignment(E->getArg(1));
 6417       Ops.push_back(EmitScalarExpr(E->getArg(i)));
 6422       bool IsConst = E->getArg(i)->isIntegerConstantExpr(Result, getContext());
 6444     Value *Arg = EmitScalarExpr(E->getArg(0));
 6625   const Expr *Arg = E->getArg(E->getNumArgs()-1);
 6831     auto Addr = E->getArg(0);
 6853     auto Addr = E->getArg(0);
 6857     auto MvecCType = E->getArg(1)->getType();
 6872     EmitAggExpr(E->getArg(1), MvecSlot);
 6932   const Expr *Arg = E->getArg(E->getNumArgs() - 1);
 7084     Value *Address         = EmitScalarExpr(E->getArg(0));
 7085     Value *RW              = EmitScalarExpr(E->getArg(1));
 7086     Value *CacheLevel      = EmitScalarExpr(E->getArg(2));
 7087     Value *RetentionPolicy = EmitScalarExpr(E->getArg(3));
 7088     Value *IsData          = EmitScalarExpr(E->getArg(4));
 7109     llvm::Value *Arg = EmitScalarExpr(E->getArg(0));
 7116     llvm::Value *Arg = EmitScalarExpr(E->getArg(0));
 7122     llvm::Value *Arg = EmitScalarExpr(E->getArg(0));
 7127     llvm::Value *Arg = EmitScalarExpr(E->getArg(0));
 7135     llvm::Value *Arg = EmitScalarExpr(E->getArg(0));
 7145       Ops[i] = EmitScalarExpr(E->getArg(i));
 7159     Value *LdPtr = EmitScalarExpr(E->getArg(0));
 7175     Value *LoadAddr = EmitScalarExpr(E->getArg(0));
 7200       getContext().getTypeSize(E->getArg(0)->getType()) == 128) {
 7206     Address Tmp = CreateMemTemp(E->getArg(0)->getType());
 7207     EmitAnyExprToMem(E->getArg(0), Tmp, Qualifiers(), /*init*/ true);
 7214     Value *StPtr = Builder.CreateBitCast(EmitScalarExpr(E->getArg(1)),
 7221     Value *StoreVal = EmitScalarExpr(E->getArg(0));
 7222     Value *StoreAddr = EmitScalarExpr(E->getArg(1));
 7224     QualType Ty = E->getArg(0)->getType();
 7248     if (!E->getArg(0)->EvaluateAsInt(Result, CGM.getContext()))
 7295     Value *Arg0 = EmitScalarExpr(E->getArg(0));
 7296     Value *Arg1 = EmitScalarExpr(E->getArg(1));
 7326       Value *Pointer = EmitScalarExpr(E->getArg(0));
 7327       Value *Mask = EmitScalarExpr(E->getArg(1));
 7336       Value *Pointer = EmitScalarExpr(E->getArg(0));
 7337       Value *TagOffset = EmitScalarExpr(E->getArg(1));
 7346       Value *Pointer = EmitScalarExpr(E->getArg(0));
 7347       Value *ExcludedMask = EmitScalarExpr(E->getArg(1));
 7358       Value *TagAddress = EmitScalarExpr(E->getArg(0));
 7368         Value *TagAddress = EmitScalarExpr(E->getArg(0));
 7374       Value *PointerA = EmitScalarExpr(E->getArg(0));
 7375       Value *PointerB = EmitScalarExpr(E->getArg(1));
 7418       E->getArg(0)->EvaluateKnownConstInt(getContext()).getZExtValue();
 7442     llvm::Value *ArgValue = EmitScalarExpr(E->getArg(1));
 7468       Ops.push_back(EmitScalarExpr(E->getArg(i)));
 7473       bool IsConst = E->getArg(i)->isIntegerConstantExpr(Result, getContext());
 7485     Ops.push_back(EmitScalarExpr(E->getArg(E->getNumArgs() - 1)));
 7492   const Expr *Arg = E->getArg(E->getNumArgs()-1);
 7505     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 7510     Value *Ptr = Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)), Int128PTy);
 7517     return Builder.CreateDefaultAlignedStore(EmitScalarExpr(E->getArg(1)), Ptr);
 7525     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 7540     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 7557     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 7575     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 7585     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 7595     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 7613     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 7644     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 7665     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 7682     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 7698     Value *Vec = EmitScalarExpr(E->getArg(0));
 7711     Value *Vec = EmitScalarExpr(E->getArg(0));
 7724     Value *Vec = EmitScalarExpr(E->getArg(0));
 7738     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 7746     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 7754     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 7762     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 7770     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 7776     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 7796     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 7816     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 7836     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 7866     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 7874     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 7892     Ops.push_back(EmitScalarExpr(E->getArg(2)));
 7898     Ops.push_back(EmitScalarExpr(E->getArg(2)));
 7904     Ops.push_back(EmitScalarExpr(E->getArg(2)));
 7910     return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
 7915     return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
 7920     return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
 7925     return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
 7930     return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
 7935     return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
 7940     return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
 7945     return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
 7950     return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
 7955     return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
 7960     return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
 7965     return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
 7971     return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
 7977     return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
 7980     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 7983     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 7986     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 7989     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 7995       {EmitScalarExpr(E->getArg(1)), EmitScalarExpr(E->getArg(2)), Ops[0]});
 7995       {EmitScalarExpr(E->getArg(1)), EmitScalarExpr(E->getArg(2)), Ops[0]});
 8000     Value* Sub = Builder.CreateFSub(Zero, EmitScalarExpr(E->getArg(1)), "vsubh");
 8002     return Builder.CreateCall(F, {Sub, EmitScalarExpr(E->getArg(2)), Ops[0]});
 8006     return Builder.CreateAdd(Ops[0], EmitScalarExpr(E->getArg(1)), "vaddd");
 8009     return Builder.CreateSub(Ops[0], EmitScalarExpr(E->getArg(1)), "vsubd");
 8014     ProductOps.push_back(vectorWrapScalar16(EmitScalarExpr(E->getArg(2))));
 8027     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 8037     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 8046     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 8057     Ops.push_back(Builder.CreateNeg(EmitScalarExpr(E->getArg(2))));
 8064     llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
 8069     llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
 8076     llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
 8085     llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(2)));
 8093     llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(2)));
 8107     Ops[2] = Builder.CreateExtractElement(Ops[2], EmitScalarExpr(E->getArg(3)),
 8129     ProductOps.push_back(EmitScalarExpr(E->getArg(2)));
 8143     Ops[2] = Builder.CreateExtractElement(Ops[2], EmitScalarExpr(E->getArg(3)),
 8160     return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
 8164     return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
 8305     Value *Arg0 = EmitScalarExpr(E->getArg(0));
 8306     Value *Arg1 = EmitScalarExpr(E->getArg(1));
 8414     Ops.push_back(EmitScalarExpr(E->getArg(3)));
 8432     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 8443     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 8486     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 8494     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 8498     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 8503     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 8507     Ops.push_back(EmitScalarExpr(E->getArg(1)));
 8526     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8536     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8541     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8551     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8561     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8566     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8576     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8586     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8707     Ops.push_back(EmitScalarExpr(E->getArg(2)));
 8728     return Builder.CreateNeg(EmitScalarExpr(E->getArg(0)), "vnegd");
 8730     return Builder.CreateFNeg(EmitScalarExpr(E->getArg(0)), "vnegh");
 8742     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8766     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8778     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8790     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8802     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8811     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8820     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8829     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8838     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8847     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8856     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8865     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8874     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8883     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8892     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8901     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8910     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8919     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8928     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8937     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8946     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8955     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8964     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8973     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8982     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 8991     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 9000     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 9009     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 9018     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 9024     Value *RHS = Builder.CreateBitCast(EmitScalarExpr(E->getArg(1)), DoubleTy);
 9032     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 9041     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 9049     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 9058     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 9066     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 9075     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 9083     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 9092     Ops.push_back(EmitScalarExpr(E->getArg(0)));
 9437   const Expr *Arg = E->getArg(0);
 9453   ConstantInt *C = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
10005   const Expr *CPUExpr = E->getArg(0)->IgnoreParenCasts();
10068   const Expr *FeatureExpr = E->getArg(0)->IgnoreParenCasts();
10176       Ops.push_back(EmitScalarExpr(E->getArg(i)));
10183     bool IsConst = E->getArg(i)->isIntegerConstantExpr(Result, getContext());
10309     Address Tmp = CreateMemTemp(E->getArg(0)->getType());
10506       getContext().getTypeAlignInChars(E->getArg(1)->getType()).getQuantity();
10546       getContext().getTypeAlignInChars(E->getArg(1)->getType()).getQuantity();
12202     Address HighBitsAddress = EmitPointerWithAlignment(E->getArg(2));
12384     Ops.push_back(EmitScalarExpr(E->getArg(i)));
12531     Value *X = EmitScalarExpr(E->getArg(0));
12542     Value *X = EmitScalarExpr(E->getArg(0));
12552     Value *X = EmitScalarExpr(E->getArg(0));
12562     Value *X = EmitScalarExpr(E->getArg(0));
12570     Value *X = EmitScalarExpr(E->getArg(0));
12571     Value *Y = EmitScalarExpr(E->getArg(1));
12588     Value *X = EmitScalarExpr(E->getArg(0));
12612     Value *X = EmitScalarExpr(E->getArg(0));
12627     Value *X = EmitScalarExpr(E->getArg(0));
12628     Value *Y = EmitScalarExpr(E->getArg(1));
12629     Value *Z = EmitScalarExpr(E->getArg(2));
12831     Address FlagOutPtr = EmitPointerWithAlignment(E->getArg(3));
12833     llvm::Value *X = EmitScalarExpr(E->getArg(0));
12834     llvm::Value *Y = EmitScalarExpr(E->getArg(1));
12835     llvm::Value *Z = EmitScalarExpr(E->getArg(2));
12854     llvm::Value *Src0 = EmitScalarExpr(E->getArg(0));
12855     llvm::Value *Src1 = EmitScalarExpr(E->getArg(1));
12856     llvm::Value *Src2 = EmitScalarExpr(E->getArg(2));
12857     llvm::Value *Src3 = EmitScalarExpr(E->getArg(3));
12873       Args.push_back(EmitScalarExpr(E->getArg(I)));
12917     Value *Src0 = EmitScalarExpr(E->getArg(0));
12923     Value *Src0 = EmitScalarExpr(E->getArg(0));
12942     llvm::Value *Src0 = EmitScalarExpr(E->getArg(0));
12943     llvm::Value *Src1 = EmitScalarExpr(E->getArg(1));
12944     llvm::Value *Src2 = EmitScalarExpr(E->getArg(2));
12953     llvm::Value *Src0 = EmitScalarExpr(E->getArg(0));
12954     llvm::Value *Src1 = EmitScalarExpr(E->getArg(1));
12955     llvm::Value *Src2 = EmitScalarExpr(E->getArg(2));
12973     Value *Src0 = EmitScalarExpr(E->getArg(0));
13024     Args[I] = CGF.EmitScalarExpr(E->getArg(I));
13025   Address CCPtr = CGF.EmitPointerWithAlignment(E->getArg(NumArgs));
13037     Value *TDB = EmitScalarExpr(E->getArg(0));
13043     Value *TDB = EmitScalarExpr(E->getArg(0));
13055     Value *Data = EmitScalarExpr(E->getArg(0));
13060     Value *Address = EmitScalarExpr(E->getArg(0));
13061     Value *Data = EmitScalarExpr(E->getArg(1));
13076     Value *X = EmitScalarExpr(E->getArg(0));
13086     Value *X = EmitScalarExpr(E->getArg(0));
13097     Value *X = EmitScalarExpr(E->getArg(0));
13106     Value *X = EmitScalarExpr(E->getArg(0));
13113     Value *X = EmitScalarExpr(E->getArg(0));
13114     Value *Y = EmitScalarExpr(E->getArg(1));
13115     Value *Z = EmitScalarExpr(E->getArg(2));
13122     Value *X = EmitScalarExpr(E->getArg(0));
13123     Value *Y = EmitScalarExpr(E->getArg(1));
13124     Value *Z = EmitScalarExpr(E->getArg(2));
13132     Value *X = EmitScalarExpr(E->getArg(0));
13133     Value *Y = EmitScalarExpr(E->getArg(1));
13134     Value *Z = EmitScalarExpr(E->getArg(2));
13142     Value *X = EmitScalarExpr(E->getArg(0));
13143     Value *Y = EmitScalarExpr(E->getArg(1));
13144     Value *Z = EmitScalarExpr(E->getArg(2));
13153     Value *X = EmitScalarExpr(E->getArg(0));
13160     Value *X = EmitScalarExpr(E->getArg(0));
13168     Value *X = EmitScalarExpr(E->getArg(0));
13171     bool IsConstM4 = E->getArg(1)->isIntegerConstantExpr(M4, getContext());
13172     bool IsConstM5 = E->getArg(2)->isIntegerConstantExpr(M5, getContext());
13214     Value *X = EmitScalarExpr(E->getArg(0));
13215     Value *Y = EmitScalarExpr(E->getArg(1));
13218     bool IsConstM4 = E->getArg(2)->isIntegerConstantExpr(M4, getContext());
13244     Value *X = EmitScalarExpr(E->getArg(0));
13245     Value *Y = EmitScalarExpr(E->getArg(1));
13248     bool IsConstM4 = E->getArg(2)->isIntegerConstantExpr(M4, getContext());
13276     Value *X = EmitScalarExpr(E->getArg(0));
13618     Value *Ptr = EmitScalarExpr(E->getArg(0));
13620         getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
13627     Value *Ptr = EmitScalarExpr(E->getArg(0));
13631         {Ptr, EmitScalarExpr(E->getArg(1))});
13693     Value *Ptr = EmitScalarExpr(E->getArg(0));
13694     Value *Val = EmitScalarExpr(E->getArg(1));
13700     Value *Ptr = EmitScalarExpr(E->getArg(0));
13701     Value *Val = EmitScalarExpr(E->getArg(1));
13708     Value *Ptr = EmitScalarExpr(E->getArg(0));
13709     Value *Val = EmitScalarExpr(E->getArg(1));
13835     Value *Ptr = EmitScalarExpr(E->getArg(0));
13840         {Ptr, EmitScalarExpr(E->getArg(1)), EmitScalarExpr(E->getArg(2))});
13840         {Ptr, EmitScalarExpr(E->getArg(1)), EmitScalarExpr(E->getArg(2))});
13845     Value *Ptr = EmitScalarExpr(E->getArg(0));
13850         {Ptr, EmitScalarExpr(E->getArg(1)), EmitScalarExpr(E->getArg(2))});
13850         {Ptr, EmitScalarExpr(E->getArg(1)), EmitScalarExpr(E->getArg(2))});
13854     Value *Mask = EmitScalarExpr(E->getArg(0));
13855     Value *Val = EmitScalarExpr(E->getArg(1));
13856     Address PredOutPtr = EmitPointerWithAlignment(E->getArg(2));
13907     Address Dst = EmitPointerWithAlignment(E->getArg(0));
13908     Value *Src = EmitScalarExpr(E->getArg(1));
13909     Value *Ldm = EmitScalarExpr(E->getArg(2));
13911     if (!E->getArg(3)->isIntegerConstantExpr(isColMajorArg, getContext()))
13951     Value *Dst = EmitScalarExpr(E->getArg(0));
13952     Address Src = EmitPointerWithAlignment(E->getArg(1));
13953     Value *Ldm = EmitScalarExpr(E->getArg(2));
13955     if (!E->getArg(3)->isIntegerConstantExpr(isColMajorArg, getContext()))
14000     Address Dst = EmitPointerWithAlignment(E->getArg(0));
14001     Address SrcA = EmitPointerWithAlignment(E->getArg(1));
14002     Address SrcB = EmitPointerWithAlignment(E->getArg(2));
14003     Address SrcC = EmitPointerWithAlignment(E->getArg(3));
14005     if (!E->getArg(4)->isIntegerConstantExpr(LayoutArg, getContext()))
14013     else if (!E->getArg(5)->isIntegerConstantExpr(SatfArg, getContext()))
14070     Value *I = EmitScalarExpr(E->getArg(0));
14077       EmitScalarExpr(E->getArg(0)),
14078       EmitScalarExpr(E->getArg(1))
14085     if (!E->getArg(0)->isIntegerConstantExpr(SegConst, getContext()))
14088     if (!E->getArg(1)->isIntegerConstantExpr(MemConst, getContext()))
14094                      EmitScalarExpr(E->getArg(2)), EmitScalarExpr(E->getArg(3)),
14094                      EmitScalarExpr(E->getArg(2)), EmitScalarExpr(E->getArg(3)),
14095                      EmitScalarExpr(E->getArg(4))};
14101     if (!E->getArg(0)->isIntegerConstantExpr(SegConst, getContext()))
14122     Value *Tag = EmitScalarExpr(E->getArg(0));
14123     Value *Obj = EmitScalarExpr(E->getArg(1));
14132     Value *Addr = EmitScalarExpr(E->getArg(0));
14133     Value *Expected = EmitScalarExpr(E->getArg(1));
14134     Value *Timeout = EmitScalarExpr(E->getArg(2));
14139     Value *Addr = EmitScalarExpr(E->getArg(0));
14140     Value *Expected = EmitScalarExpr(E->getArg(1));
14141     Value *Timeout = EmitScalarExpr(E->getArg(2));
14146     Value *Addr = EmitScalarExpr(E->getArg(0));
14147     Value *Count = EmitScalarExpr(E->getArg(1));
14155     Value *Src = EmitScalarExpr(E->getArg(0));
14165     Value *Src = EmitScalarExpr(E->getArg(0));
14177     Value *Src = EmitScalarExpr(E->getArg(0));
14189     Value *Src = EmitScalarExpr(E->getArg(0));
14199     Value *LHS = EmitScalarExpr(E->getArg(0));
14200     Value *RHS = EmitScalarExpr(E->getArg(1));
14209     Value *LHS = EmitScalarExpr(E->getArg(0));
14210     Value *RHS = EmitScalarExpr(E->getArg(1));
14216     Value *Src = EmitScalarExpr(E->getArg(0));
14217     Value *Indices = EmitScalarExpr(E->getArg(1));
14230     if (!E->getArg(1)->isIntegerConstantExpr(LaneConst, getContext()))
14232     Value *Vec = EmitScalarExpr(E->getArg(0));
14258     if (!E->getArg(1)->isIntegerConstantExpr(LaneConst, getContext()))
14260     Value *Vec = EmitScalarExpr(E->getArg(0));
14262     Value *Val = EmitScalarExpr(E->getArg(2));
14308     Value *LHS = EmitScalarExpr(E->getArg(0));
14309     Value *RHS = EmitScalarExpr(E->getArg(1));
14314     Value *V1 = EmitScalarExpr(E->getArg(0));
14315     Value *V2 = EmitScalarExpr(E->getArg(1));
14316     Value *C = EmitScalarExpr(E->getArg(2));
14346     Value *Vec = EmitScalarExpr(E->getArg(0));
14352     Value *Vec = EmitScalarExpr(E->getArg(0));
14358     Value *Vec = EmitScalarExpr(E->getArg(0));
14366     Value *A = EmitScalarExpr(E->getArg(0));
14367     Value *B = EmitScalarExpr(E->getArg(1));
14368     Value *C = EmitScalarExpr(E->getArg(2));
14389     Value *Low = EmitScalarExpr(E->getArg(0));
14390     Value *High = EmitScalarExpr(E->getArg(1));
14416     Value *Vec = EmitScalarExpr(E->getArg(0));
14454     Address BP = EmitPointerWithAlignment(E->getArg(0));
14460       Ops = { Base, EmitScalarExpr(E->getArg(1)), EmitScalarExpr(E->getArg(2)),
14460       Ops = { Base, EmitScalarExpr(E->getArg(1)), EmitScalarExpr(E->getArg(2)),
14461               EmitScalarExpr(E->getArg(3)) };
14463       Ops = { Base, EmitScalarExpr(E->getArg(1)),
14464               EmitScalarExpr(E->getArg(2)) };
14468     llvm::Value *LV = Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)),
14470     Address Dest = EmitPointerWithAlignment(E->getArg(0));
14479     Address BP = EmitPointerWithAlignment(E->getArg(0));
14485       Ops = { Base, EmitScalarExpr(E->getArg(1)), EmitScalarExpr(E->getArg(2)),
14485       Ops = { Base, EmitScalarExpr(E->getArg(1)), EmitScalarExpr(E->getArg(2)),
14486               EmitScalarExpr(E->getArg(3)), EmitScalarExpr(E->getArg(4)) };
14486               EmitScalarExpr(E->getArg(3)), EmitScalarExpr(E->getArg(4)) };
14488       Ops = { Base, EmitScalarExpr(E->getArg(1)),
14489               EmitScalarExpr(E->getArg(2)), EmitScalarExpr(E->getArg(3)) };
14489               EmitScalarExpr(E->getArg(2)), EmitScalarExpr(E->getArg(3)) };
14492     llvm::Value *LV = Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)),
14494     Address Dest = EmitPointerWithAlignment(E->getArg(0));
14508         Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)), Int8PtrTy);
14513     Address DestAddr = EmitPointerWithAlignment(E->getArg(1));
14521     Ops = {BaseAddress, EmitScalarExpr(E->getArg(2))};
14542     Address Dest = EmitPointerWithAlignment(E->getArg(2));
14554     Ops = { EmitScalarExpr(E->getArg(0)), EmitScalarExpr(E->getArg(1)), QLd };
14554     Ops = { EmitScalarExpr(E->getArg(0)), EmitScalarExpr(E->getArg(1)), QLd };
14557     llvm::Value *Base = Builder.CreateBitCast(EmitScalarExpr(E->getArg(2)),
14564     Address Dest = EmitPointerWithAlignment(E->getArg(2));
14576     Ops = { EmitScalarExpr(E->getArg(0)), EmitScalarExpr(E->getArg(1)), QLd };
14576     Ops = { EmitScalarExpr(E->getArg(0)), EmitScalarExpr(E->getArg(1)), QLd };
14579     llvm::Value *Base = Builder.CreateBitCast(EmitScalarExpr(E->getArg(2)),

tools/clang/lib/CodeGen/CGExprCXX.cpp

  470       /*IsArrow=*/false, E->getArg(0));

tools/clang/lib/CodeGen/CGExprConstant.cpp

 1965   auto literal = cast<StringLiteral>(E->getArg(0)->IgnoreParenCasts());

tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp

  812     const Expr *LHS = CE->getArg(/*Arg=*/0)->IgnoreParenImpCasts();
  813     const Expr *RHS = CE->getArg(/*Arg=*/1)->IgnoreParenImpCasts();

tools/clang/lib/Index/IndexBody.cpp

  108         if (CXXOp->getNumArgs() > 0 && CXXOp->getArg(0)->IgnoreParenCasts() == E) {

tools/clang/lib/Sema/SemaChecking.cpp

 6963         const Expr *Arg = CE->getArg(FA->getFormatIdx().getASTIndex());
 6980           const Expr *Arg = CE->getArg(0);
 9175   QualType ArgType = Call->getArg(0)->IgnoreParenImpCasts()->getType();
 9176   QualType ParamType = Call->getArg(0)->getType();
 9276   const Expr *FirstArg = Call->getArg(0);
 9277   const Expr *SecondArg = Call->getArg(1);
 9529     Call->getArg(BId == Builtin::BImemset ? 2 : 1)->IgnoreImpCasts();
 9550     } else if (!isLiteralZero(Call->getArg(1)->IgnoreImpCasts())) {
 9561       doesExprLikelyComputeSize(Call->getArg(1)) &&
 9562       !doesExprLikelyComputeSize(Call->getArg(2))) {
 9563     SourceLocation DiagLoc = Call->getArg(1)->getExprLoc();
 9593   const Expr *LenExpr = Call->getArg(LenArg)->IgnoreParenImpCasts();
 9610   QualType FirstArgTy = Call->getArg(0)->IgnoreParenImpCasts()->getType();
 9615     const Expr *Dest = Call->getArg(ArgIdx)->IgnoreParenImpCasts();
 9616     SourceRange ArgRange = Call->getArg(ArgIdx)->getSourceRange();
 9813   const Expr *SrcArg = ignoreLiteralAdditions(Call->getArg(1), Context);
 9814   const Expr *SizeArg = ignoreLiteralAdditions(Call->getArg(2), Context);
 9829         CompareWithSrc = ignoreLiteralAdditions(SizeCall->getArg(0), Context);
 9849   const Expr *OriginalSizeArg = Call->getArg(2);
 9857   const Expr *DstArg = Call->getArg(0)->IgnoreParenImpCasts();
 9885     return CE->getArg(0)->IgnoreParenCasts();
 9898   const Expr *DstArg = CE->getArg(0)->IgnoreParenCasts();
 9899   const Expr *SrcArg = CE->getArg(1)->IgnoreParenCasts();
 9900   const Expr *LenArg = CE->getArg(2)->IgnoreParenCasts();
14151   RHSExpr = CE->getArg(0);

tools/clang/lib/Sema/SemaInit.cpp

 7610   const Expr *Arg = CE->getArg(0)->IgnoreImplicit();

tools/clang/lib/Sema/SemaStmt.cpp

  171     CanAssign = Op->getArg(0)->IgnoreParenImpCasts()->isLValue();

tools/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp

  444   SVal TheTypeVal = C.getSVal(CE->getArg(1));
  464   SVal TheValueExpr = C.getSVal(CE->getArg(2));
  524     report->addRange(CE->getArg(2)->getSourceRange());

tools/clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp

 1243   const Expr *Dest = CE->getArg(0);
 1246   evalCopyCommon(C, CE, state, CE->getArg(2), Dest, CE->getArg(1), true);
 1246   evalCopyCommon(C, CE, state, CE->getArg(2), Dest, CE->getArg(1), true);
 1252   const Expr *Dest = CE->getArg(0);
 1255   evalCopyCommon(C, CE, state, CE->getArg(2), Dest, CE->getArg(1), true, true);
 1255   evalCopyCommon(C, CE, state, CE->getArg(2), Dest, CE->getArg(1), true, true);
 1261   const Expr *Dest = CE->getArg(0);
 1264   evalCopyCommon(C, CE, state, CE->getArg(2), Dest, CE->getArg(1));
 1264   evalCopyCommon(C, CE, state, CE->getArg(2), Dest, CE->getArg(1));
 1270                  CE->getArg(2), CE->getArg(1), CE->getArg(0));
 1270                  CE->getArg(2), CE->getArg(1), CE->getArg(0));
 1270                  CE->getArg(2), CE->getArg(1), CE->getArg(0));
 1277   const Expr *Left = CE->getArg(0);
 1278   const Expr *Right = CE->getArg(1);
 1279   const Expr *Size = CE->getArg(2);
 1365     const Expr *maxlenExpr = CE->getArg(1);
 1389   const Expr *Arg = CE->getArg(0);
 1413     const Expr *maxlenExpr = CE->getArg(1);
 1547   const Expr *Dst = CE->getArg(0);
 1555   const Expr *srcExpr = CE->getArg(1);
 1579   state = CheckOverlap(C, state, isBounded ? CE->getArg(2) : CE->getArg(1), Dst, srcExpr);
 1579   state = CheckOverlap(C, state, isBounded ? CE->getArg(2) : CE->getArg(1), Dst, srcExpr);
 1587     const Expr *lenExpr = CE->getArg(2);
 1815         state = CheckLocation(C, state, CE->getArg(2), maxLastElement,
 1911   const Expr *s1 = CE->getArg(0);
 1918   const Expr *s2 = CE->getArg(1);
 1977       const Expr *lenExpr = CE->getArg(2);
 2034   const Expr *SearchStrPtr = CE->getArg(0);
 2052   const Expr *DelimStr = CE->getArg(1);
 2101   if (!CE->getArg(2)->getType()->isPointerType())
 2114   const Expr *Dst = CE->getArg(2);
 2130   const Expr *Mem = CE->getArg(0);
 2131   const Expr *CharE = CE->getArg(1);
 2132   const Expr *Size = CE->getArg(2);
 2178   const Expr *Mem = CE->getArg(0);
 2179   const Expr *Size = CE->getArg(1);

tools/clang/lib/StaticAnalyzer/Checkers/CStringSyntaxChecker.cpp

   60               sameDecl(CE->getArg(0), WithArg));
  125   const Expr *DstArg = CE->getArg(0);
  126   const Expr *SrcArg = CE->getArg(1);
  127   const Expr *LenArg = CE->getArg(2);
  156   const Expr *DstArg = CE->getArg(0);
  157   const Expr *LenArg = CE->getArg(2);

tools/clang/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp

  595     dyn_cast<StringLiteral>(CE->getArg((unsigned)ArgSuffix.first)
  612     const Expr *suffixEx = CE->getArg((unsigned)ArgSuffix.second);
  666   const auto *Target = CE->getArg(0)->IgnoreImpCasts(),
  667              *Source = CE->getArg(1)->IgnoreImpCasts();
  768         dyn_cast<StringLiteral>(CE->getArg(ArgIndex)->IgnoreParenImpCasts());

tools/clang/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp

  112   const Expr *Assertion = CE->getArg(0);
  203   SVal V = C.getSVal(CE->getArg(0));
  215   SVal V = C.getSVal(CE->getArg(0));
  230   auto MR = dyn_cast_or_null<SubRegion>(C.getSVal(CE->getArg(0)).getAsRegion());
  251   SVal Val = C.getSVal(CE->getArg(0));
  306   FullSourceLoc FL(CE->getArg(0)->getBeginLoc(), SM);
  322   SymbolRef Sym = C.getSVal(CE->getArg(0)).getAsSymbol();
  328   const auto *E = dyn_cast<StringLiteral>(CE->getArg(1)->IgnoreParenCasts());
  397   SymbolRef Sym = C.getSVal(CE->getArg(0)).getAsSymbol();

tools/clang/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp

  516     const Expr *Arg = CE->getArg(ArgNum);
  594     if ((IsTainted = isTaintedOrPointsToTainted(CE->getArg(ArgNum), State, C)))
  602       if ((IsTainted = isTaintedOrPointsToTainted(CE->getArg(i), State, C)))
  635       const Expr *Arg = CE->getArg(i);
  652   SourceLocation DomLoc = CE->getArg(0)->getExprLoc();
  757   return generateReportIfTainted(CE->getArg(ArgNum),
  782   return generateReportIfTainted(CE->getArg(ArgNum), MsgSanitizeSystemArgs, C);
  821          generateReportIfTainted(CE->getArg(ArgNum), MsgTaintedBufferSize, C);
  835     if (generateReportIfTainted(CE->getArg(ArgNum), MsgCustomSink, C))

tools/clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp

  269     const Expr *ArgExpr = CE->getArg(paramIdx);
  306   const Expr *ArgExpr = CE->getArg(paramIdx);
  354       const Expr *DeallocatorExpr = CE->getArg(5)->IgnoreParenCasts();
  416   const Expr *ArgExpr = CE->getArg(FunctionsToTrack[idx].Param);
  643   const Expr *ArgExpr = CE->getArg(FunctionsToTrack[Idx].Param);

tools/clang/lib/StaticAnalyzer/Checkers/MacOSXAPIChecker.cpp

   71   const MemRegion *R = C.getSVal(CE->getArg(0)).getAsRegion();
  144   report->addRange(CE->getArg(0)->getSourceRange());

tools/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp

 1012   const Expr *FlagsEx = CE->getArg(CE->getNumArgs() - 1);
 1038     return MallocMemAux(C, CE, CE->getArg(0), ZeroVal, TrueState);
 1077         State = MallocMemAux(C, CE, CE->getArg(0), UndefinedVal(), State);
 1081         State = MallocMemAux(C, CE, CE->getArg(0), UndefinedVal(), State);
 1089           State = MallocMemAux(C, CE, CE->getArg(0), UndefinedVal(), State);
 1100         State = MallocMemAux(C, CE, CE->getArg(0), UndefinedVal(), State);
 1104       State = MallocMemAux(C, CE, CE->getArg(0), UndefinedVal(), State);
 1136       State = MallocMemAux(C, CE, CE->getArg(0), UndefinedVal(), State,
 1146         State = MallocMemAux(C, CE, CE->getArg(0), UndefinedVal(), State,
 1151         State = MallocMemAux(C, CE, CE->getArg(0), UndefinedVal(), State,
 1175       State = MallocMemAux(C, CE, CE->getArg(0), zeroVal, State);
 1180       State = MallocMemAux(C, CE, CE->getArg(1), UndefinedVal(), State);
 1194       SVal TotalSize = evalMulForBufferSize(C, CE->getArg(0), CE->getArg(1));
 1194       SVal TotalSize = evalMulForBufferSize(C, CE->getArg(0), CE->getArg(1));
 1242     Arg = CE->getArg(IndexOfSizeArg);
 1493     return MallocMemAux(C, CE, CE->getArg(I->getASTIndex()), UndefinedVal(),
 1610   return FreeMemAux(C, CE->getArg(Num), CE, State, Hold, IsKnownToBeAllocated,
 2405   const Expr *arg0Expr = CE->getArg(0);
 2417   const Expr *Arg1 = CE->getArg(1);
 2422     TotalSize = evalMulForBufferSize(C, Arg1, CE->getArg(2));
 2507   SVal TotalSize = evalMulForBufferSize(C, CE->getArg(0), CE->getArg(1));
 2507   SVal TotalSize = evalMulForBufferSize(C, CE->getArg(0), CE->getArg(1));

tools/clang/lib/StaticAnalyzer/Checkers/MallocOverflowSecurityChecker.cpp

  325               CheckMallocArgument(PossibleMallocOverflows, TheCall->getArg(0),

tools/clang/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp

   99     addSizeInfo(CE, CE->getArg(2), C);
  104     addSizeInfo(CE->getArg(0), CE, C);
  121     const Expr *ArrayExpr = CE->getArg(0);
  132     const Expr *IdxExpr = CE->getArg(1);

tools/clang/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp

  121     AcquireLock(C, CE, C.getSVal(CE->getArg(0)), false, PthreadSemantics);
  125     AcquireLock(C, CE, C.getSVal(CE->getArg(0)), false, XNUSemantics);
  129     AcquireLock(C, CE, C.getSVal(CE->getArg(0)),
  134     AcquireLock(C, CE, C.getSVal(CE->getArg(0)), true, XNUSemantics);
  139     ReleaseLock(C, CE, C.getSVal(CE->getArg(0)));
  141     DestroyLock(C, CE, C.getSVal(CE->getArg(0)), PthreadSemantics);
  143     DestroyLock(C, CE, C.getSVal(CE->getArg(0)), XNUSemantics);
  145     InitLock(C, CE, C.getSVal(CE->getArg(0)));
  245       report->addRange(CE->getArg(0)->getSourceRange());
  310       Report->addRange(CE->getArg(0)->getSourceRange());
  334       report->addRange(CE->getArg(0)->getSourceRange());
  404   Report->addRange(CE->getArg(0)->getSourceRange());
  444   Report->addRange(CE->getArg(0)->getSourceRange());
  458   Report->addRange(CE->getArg(0)->getSourceRange());

tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp

  925             : CE->getArg(0);

tools/clang/lib/StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp

  219                         : CE->getArg(ArgNo)->getType().getCanonicalType();

tools/clang/lib/StaticAnalyzer/Checkers/StreamChecker.cpp

  249   if (!CheckNullStream(C.getSVal(CE->getArg(3)), state, C))
  255   if (!CheckNullStream(C.getSVal(CE->getArg(3)), state, C))
  261   if (!(state = CheckNullStream(C.getSVal(CE->getArg(0)), state, C)))
  264   SVal Whence = state->getSVal(CE->getArg(2), C.getLocationContext());
  287   if (!CheckNullStream(C.getSVal(CE->getArg(0)), state, C))
  293   if (!CheckNullStream(C.getSVal(CE->getArg(0)), state, C))
  299   if (!CheckNullStream(C.getSVal(CE->getArg(0)), state, C))
  305   if (!CheckNullStream(C.getSVal(CE->getArg(0)), state, C))
  311   if (!CheckNullStream(C.getSVal(CE->getArg(0)), state, C))
  317   if (!CheckNullStream(C.getSVal(CE->getArg(0)), state, C))
  323   if (!CheckNullStream(C.getSVal(CE->getArg(0)), state, C))
  329   if (!CheckNullStream(C.getSVal(CE->getArg(0)), state, C))
  359   SymbolRef Sym = C.getSVal(CE->getArg(0)).getAsSymbol();

tools/clang/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp

  188     const Expr *Arg = CE->getArg(CreateModeArgIndex);
  210                   CE->getArg(MaxArgCount)->getSourceRange());
  230   const Expr *oflagsEx = CE->getArg(FlagsArgIndex);
  285   const MemRegion *R = C.getSVal(CE->getArg(0)).getAsRegion();
  309   report->addRange(CE->getArg(0)->getSourceRange());
  375   const Expr *arg = CE->getArg(sizeArg);
  403     const Expr *arg = CE->getArg(i);

tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp

  844   return getOriginExpr()->getArg(0);

tools/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

 1573             createTemporaryRegionIfNeeded(State, LCtx, OCE->getArg(0));

tools/clang/lib/Tooling/Transformer/RangeSelector.cpp

  103       E.getNumArgs() == 0 ? E.getRParenLoc() : E.getArg(0)->getBeginLoc();

tools/clang/tools/extra/clang-tidy/abseil/DurationAdditionCheck.cpp

   53          tooling::fixit::getText(*Call->getArg(0), *Result.Context) + " + " +
   63          " + " + tooling::fixit::getText(*Call->getArg(0), *Result.Context) +

tools/clang/tools/extra/clang-tidy/abseil/DurationFactoryFloatCheck.cpp

   51   const Expr *Arg = MatchedCall->getArg(0)->IgnoreImpCasts();

tools/clang/tools/extra/clang-tidy/abseil/DurationFactoryScaleCheck.cpp

  147   const Expr *Arg = Call->getArg(0)->IgnoreParenImpCasts();

tools/clang/tools/extra/clang-tidy/abseil/RedundantStrcatCallsCheck.cpp

   55           Call->getBeginLoc(), Call->getArg(0)->getBeginLoc())));

tools/clang/tools/extra/clang-tidy/abseil/StrCatAppendCheck.cpp

   96       << FixItHint::CreateInsertion(Call->getArg(0)->getBeginLoc(), "&");

tools/clang/tools/extra/clang-tidy/abseil/TimeSubtractionCheck.cpp

  167     if (MaybeCallArg && MaybeCallArg->getArg(0)->IgnoreImpCasts() == BinOp &&

tools/clang/tools/extra/clang-tidy/android/CloexecCheck.cpp

   56   const auto *FlagArg = MatchedCall->getArg(ArgPos);
   86   const auto *ModeArg = MatchedCall->getArg(ArgPos);
  107       CharSourceRange::getTokenRange(MatchedCall->getArg(N)->getSourceRange()),

tools/clang/tools/extra/clang-tidy/boost/UseToStringCheck.cpp

   68                                     Call->getArg(0)->getBeginLoc()),

tools/clang/tools/extra/clang-tidy/bugprone/MisplacedOperatorInStrlenInAllocCheck.cpp

   87       CharSourceRange::getTokenRange(StrLen->getArg(0)->getSourceRange()),

tools/clang/tools/extra/clang-tidy/bugprone/NotNullTerminatedResultCheck.cpp

  131     if (const Expr *Arg = StrlenCE->getArg(0)->IgnoreImpCasts())
  240             dyn_cast<DeclRefExpr>(StrlenCE->getArg(0)->IgnoreImpCasts()))
  375   lengthExprHandle(FunctionExpr->getArg(ArgPos), LengthHandle, Result, Diag);
  414   const Expr *ArgToRemove = FunctionExpr->getArg(ArgPos);
  415   const Expr *LHSArg = FunctionExpr->getArg(ArgPos - 1);
  464       FunctionExpr->getArg(1)->getBeginLoc(), NewSecondArg);
  916   if (const auto GivenCL = dyn_cast<CharacterLiteral>(FunctionExpr->getArg(1)))
  920   auto Diag = diag(FunctionExpr->getArg(2)->IgnoreParenCasts()->getBeginLoc(),
  962   const Expr *FirstArgExpr = FunctionExpr->getArg(0)->IgnoreImpCasts();
  963   const Expr *SecondArgExpr = FunctionExpr->getArg(1)->IgnoreImpCasts();
  967     const Expr *LengthExprArg = StrlenExpr->getArg(0);
  984   auto Diag = diag(FunctionExpr->getArg(2)->IgnoreParenCasts()->getBeginLoc(),

tools/clang/tools/extra/clang-tidy/bugprone/SuspiciousMemsetUsageCheck.cpp

   95     const Expr *FillChar = Call->getArg(1);
   96     const Expr *ByteCount = Call->getArg(2);

tools/clang/tools/extra/clang-tidy/bugprone/SwappedArgumentsCheck.cpp

   55     const Expr *LHS = Call->getArg(I - 1);
   56     const Expr *RHS = Call->getArg(I);

tools/clang/tools/extra/clang-tidy/bugprone/UndefinedMemoryManipulationCheck.cpp

   51     QualType DestType = Call->getArg(0)->IgnoreImplicit()->getType();
   59     QualType SourceType = Call->getArg(1)->IgnoreImplicit()->getType();

tools/clang/tools/extra/clang-tidy/cert/ProperlySeededRandomGeneratorCheck.cpp

   96   if (Func->getNumArgs() == 0 || Func->getArg(0)->isDefaultArgument()) {
  104   if (Func->getArg(0)->EvaluateAsInt(EVResult, *Result.Context)) {
  112       Func->getArg(0)->IgnoreCasts()->getType().getAsString());

tools/clang/tools/extra/clang-tidy/cert/StrToNumCheck.cpp

  204     if (const Expr *Arg = Call->getArg(Idx)->IgnoreParenImpCasts()) {

tools/clang/tools/extra/clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp

   82           dyn_cast<CXXOperatorCallExpr>(Matched)->getArg(0)->getSourceRange();

tools/clang/tools/extra/clang-tidy/cppcoreguidelines/ProTypeVarargCheck.cpp

   41       dyn_cast<IntegerLiteral>(C->getArg(N)->IgnoreParenImpCasts());

tools/clang/tools/extra/clang-tidy/google/ExplicitMakePairCheck.cpp

   54   const Expr *Arg0 = Call->getArg(0)->IgnoreParenImpCasts();
   55   const Expr *Arg1 = Call->getArg(1)->IgnoreParenImpCasts();
   60   if (Arg0->getType() != Call->getArg(0)->getType() ||
   61       Arg1->getType() != Call->getArg(1)->getType()) {

tools/clang/tools/extra/clang-tidy/misc/RedundantExpressionCheck.cpp

  309          areEquivalentExpr(Node.getArg(0), Node.getArg(1));
  309          areEquivalentExpr(Node.getArg(0), Node.getArg(1));
  526     if (const auto *Arg = OverloadedOperatorExpr->getArg(1)) {
  531     Symbol = OverloadedOperatorExpr->getArg(0);

tools/clang/tools/extra/clang-tidy/misc/UnusedParametersCheck.cpp

   68       Result, Index > 0 ? Call->getArg(Index - 1) : nullptr,
   69       Call->getArg(Index),
   70       Index + 1 < Call->getNumArgs() ? Call->getArg(Index + 1) : nullptr));

tools/clang/tools/extra/clang-tidy/modernize/AvoidBindCheck.cpp

   53     const Expr *E = C->getArg(I);

tools/clang/tools/extra/clang-tidy/modernize/LoopConvertUtils.cpp

  225                ? OpCall->getArg(0)
  316          exprReferencesVariable(IndexVar, OpCall->getArg(0));
  396       return isIndexInSubscriptExpr(OpCall->getArg(1), IndexVar);
  408       return isIndexInSubscriptExpr(MemCall->getArg(0), IndexVar);
  556       Obj = getDeclRef(Call->getArg(0));

tools/clang/tools/extra/clang-tidy/modernize/UseEmplaceCheck.cpp

  132       Call->getExprLoc(), Call->getArg(0)->getExprLoc());

tools/clang/tools/extra/clang-tidy/mpi/BufferDerefCheck.cpp

   44     if (CE->getArg(BufferIdx)->isNullPointerConstant(
   46         tooling::fixit::getText(*CE->getArg(BufferIdx), *Result.Context) ==
   50     const Expr *ArgExpr = CE->getArg(BufferIdx);

tools/clang/tools/extra/clang-tidy/mpi/TypeMismatchCheck.cpp

  235   const QualType QT = CE->getArg(idx)->IgnoreImpCasts()->getType();
  263     if (CE->getArg(BufferIdx)->isNullPointerConstant(
  265         tooling::fixit::getText(*CE->getArg(BufferIdx), *Result.Context) ==
  270         tooling::fixit::getText(*CE->getArg(DatatypeIdx), *Result.Context);
  278     BufferExprs.push_back(CE->getArg(BufferIdx));

tools/clang/tools/extra/clang-tidy/performance/InefficientAlgorithmCheck.cpp

   84   QualType ValueType = AlgCall->getArg(2)->getType();
   91     const Expr *Arg = AlgCall->getArg(3);

tools/clang/tools/extra/clang-tidy/performance/MoveConstArgCheck.cpp

   22   const Expr *Arg = Call->getArg(0);
   64   const Expr *Arg = CallMove->getArg(0);

tools/clang/tools/extra/clang-tidy/readability/NonConstParameterCheck.cpp

   75           const Expr *Arg = CE->getArg(ArgNr++);

tools/clang/tools/extra/clang-tidy/readability/SimplifyBooleanExprCheck.cpp

  230         LHS = OpExpr->getArg(0);
  231         RHS = OpExpr->getArg(1);

tools/clang/tools/extra/clangd/refactor/tweaks/ExtractVariable.cpp

  230         if (E == Op->getArg(0) || E == Op->getArg(1))
  230         if (E == Op->getArg(0) || E == Op->getArg(1))

tools/clang/tools/libclang/CIndex.cpp

 2508     AddStmt(CE->getArg(I-1));
 2510   AddStmt(CE->getArg(0));

tools/clang/tools/libclang/CXCursor.cpp

 1213         return cxcursor::MakeCXCursor(CE->getArg(i),