| /external/llvm/lib/Analysis/ |
| GlobalsModRef.cpp | 654 const Value *LHS = GetUnderlyingObject(SI->getTrueValue(), DL);
656 if (Visited.insert(LHS).second)
657 Inputs.push_back(LHS);
771 const Value *LHS = GetUnderlyingObject(SI->getTrueValue(), DL);
773 if (Visited.insert(LHS).second)
774 Inputs.push_back(LHS);
[all...] |
| /external/llvm/lib/Target/BPF/ |
| BPFISelLowering.cpp | 464 static void NegateCC(SDValue &LHS, SDValue &RHS, ISD::CondCode &CC) {
473 std::swap(LHS, RHS);
481 SDValue LHS = Op.getOperand(2);
486 NegateCC(LHS, RHS, CC);
488 return DAG.getNode(BPFISD::BR_CC, DL, Op.getValueType(), Chain, LHS, RHS,
493 SDValue LHS = Op.getOperand(0);
500 NegateCC(LHS, RHS, CC);
505 SDValue Ops[] = {LHS, RHS, TargetCC, TrueV, FalseV};
574 unsigned LHS = MI->getOperand(1).getReg();
580 .addReg(LHS)
[all...] |
| /external/llvm/lib/Transforms/InstCombine/ |
| InstCombineSimplifyDemanded.cpp | 160 // If either the LHS or the RHS are Zero, the result is zero.
184 // If either the LHS or the RHS are One, the result is One.
242 // If either the LHS or the RHS are Zero, the result is zero.
274 // Output known-1 bits are only known if set in both the LHS & RHS.
276 // Output known-0 are known to be clear if zero in either the LHS | RHS.
280 // If either the LHS or the RHS are One, the result is One.
317 // Output known-0 bits are only known if clear in both the LHS & RHS.
319 // Output known-1 are known to be set if set in either the LHS | RHS.
331 // Output known-0 bits are known if clear or set in both the LHS & RHS.
334 // Output known-1 are known to be set if set in only one of the LHS, RHS
[all...] |
| InstCombineSelect.cpp | 387 // input to the cttz/ctlz is used as LHS for the compare instruction.
766 Value *LHS = IC->getOperand(0);
767 if (!match(LHS, m_And(m_Value(), m_ConstantInt(AndRHS))))
807 Value *V = Builder->CreateZExtOrTrunc(LHS, SI.getType());
[all...] |
| /external/llvm/lib/Transforms/Scalar/ |
| StraightLineStrengthReduce.cpp | 162 // Given I = LHS + RHS, factors RHS into i * S and makes (LHS + i * S) a
164 void allocateCandidatesAndFindBasisForAdd(Value *LHS, Value *RHS,
168 // Splits LHS into Base + Index and, if succeeds, calls
170 void allocateCandidatesAndFindBasisForMul(Value *LHS, Value *RHS,
387 Value *LHS = I->getOperand(0), *RHS = I->getOperand(1);
388 allocateCandidatesAndFindBasisForAdd(LHS, RHS, I);
389 if (LHS != RHS)
390 allocateCandidatesAndFindBasisForAdd(RHS, LHS, I);
394 Value *LHS, Value *RHS, Instruction *I)
[all...] |
| EarlyCSE.cpp | 87 static bool isEqual(SimpleValue LHS, SimpleValue RHS);
95 Value *LHS = BinOp->getOperand(0);
98 std::swap(LHS, RHS);
106 return hash_combine(BinOp->getOpcode(), Overflow, LHS, RHS);
109 return hash_combine(BinOp->getOpcode(), LHS, RHS);
113 Value *LHS = CI->getOperand(0);
117 std::swap(LHS, RHS);
120 return hash_combine(Inst->getOpcode(), Pred, LHS, RHS);
147 bool DenseMapInfo<SimpleValue>::isEqual(SimpleValue LHS, SimpleValue RHS) {
148 Instruction *LHSI = LHS.Inst, *RHSI = RHS.Inst
[all...] |
| SeparateConstOffsetFromGEP.cpp | 458 Value *LHS = BO->getOperand(0), *RHS = BO->getOperand(1);
459 // Do not trace into "or" unless it is equivalent to "add". If LHS and RHS
460 // don't have common bits, (LHS | RHS) is equivalent to (LHS + RHS).
462 !haveNoCommonBitsSet(LHS, RHS, DL, nullptr, BO, DT))
485 if (ConstantInt *ConstLHS = dyn_cast<ConstantInt>(LHS)) {
655 // If NextInChain is 0 and not the LHS of a sub, we can simplify the
[all...] |
| /external/mesa3d/src/gallium/drivers/radeon/ |
| AMDILISelLowering.cpp | 305 // Only known if known in both the LHS and RHS
493 SDValue LHS = Op.getOperand(0);
509 SDValue jq = DAG.getNode(ISD::XOR, DL, OVT, LHS, RHS);
520 // int ia = (int)LHS;
521 SDValue ia = DAG.getSExtOrTrunc(LHS, DL, INTTY);
574 SDValue LHS = Op.getOperand(0);
577 // mov r0, LHS
590 // mov r0, LHS
591 SDValue r0 = LHS;
653 SDValue LHS = DAG.getSExtOrTrunc(Op.getOperand(0), DL, INTTY)
[all...] |
| /prebuilts/gcc/linux-x86/host/x86_64-linux-glibc2.11-4.8/include/cloog/ |
| clast.h | 52 struct clast_expr* LHS;
82 const char * LHS;
114 struct clast_expr * LHS;
136 struct clast_expr *lhs, cloog_int_t rhs);
139 struct clast_assignment *new_clast_assignment(const char *lhs,
|
| /prebuilts/gcc/linux-x86/host/x86_64-linux-glibc2.15-4.8/include/cloog/ |
| clast.h | 52 struct clast_expr* LHS;
82 const char * LHS;
114 struct clast_expr * LHS;
136 struct clast_expr *lhs, cloog_int_t rhs);
139 struct clast_assignment *new_clast_assignment(const char *lhs,
|
| /external/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ |
| SymbolManager.h | 369 const SymExpr *LHS;
373 SymIntExpr(const SymExpr *lhs, BinaryOperator::Opcode op,
375 : BinarySymExpr(SymIntKind, op, t), LHS(lhs), RHS(rhs) {}
379 const SymExpr *getLHS() const { return LHS; }
382 static void Profile(llvm::FoldingSetNodeID& ID, const SymExpr *lhs,
386 ID.AddPointer(lhs);
393 Profile(ID, LHS, getOpcode(), RHS, getType());
404 const llvm::APSInt& LHS;
408 IntSymExpr(const llvm::APSInt& lhs, BinaryOperator::Opcode op
[all...] |
| /external/clang/lib/Analysis/ |
| ThreadSafetyCommon.cpp | 469 const Expr *LHS = BO->getLHS();
471 til::SExpr *E0 = translate(LHS, Ctx);
476 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(LHS)) {
[all...] |
| /external/clang/lib/StaticAnalyzer/Core/ |
| ExprEngineC.cpp | 26 Expr *LHS = B->getLHS()->IgnoreParens();
34 // With both the LHS and RHS evaluated, process the operation itself.
40 SVal LeftV = state->getSVal(LHS, LCtx);
54 // to the L-Value represented by the LHS.
56 evalStore(Tmp2, B, LHS, *it, state->BindExpr(B, LCtx, ExprVal),
78 LHS->getType()->isIntegralOrEnumerationType() &&
80 LeftV = svalBuilder.conjureSymbolVal(LHS, LCtx, LHS->getType(),
89 state = createTemporaryRegionIfNeeded(state, LCtx, LHS);
121 // Perform a load (the LHS). This performs the checks fo
[all...] |
| /external/llvm/examples/Kaleidoscope/Chapter5/ |
| toy.cpp | 141 std::unique_ptr<ExprAST> LHS, RHS;
144 BinaryExprAST(char Op, std::unique_ptr<ExprAST> LHS,
146 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
411 std::unique_ptr<ExprAST> LHS) {
419 return LHS;
431 // the pending operator take RHS as its LHS.
439 // Merge LHS/RHS.
440 LHS =
441 llvm::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS))
[all...] |
| /external/llvm/include/llvm/Analysis/ |
| ScalarEvolutionExpressions.h | 255 const SCEV *LHS;
257 SCEVUDivExpr(const FoldingSetNodeIDRef ID, const SCEV *lhs, const SCEV *rhs)
258 : SCEV(ID, scUDivExpr), LHS(lhs), RHS(rhs) {}
261 const SCEV *getLHS() const { return LHS; }
265 // In most cases the types of LHS and RHS will be the same, but in some
268 // avoid extra casts in the SCEVExpander. The LHS is more likely to be
|
| /external/llvm/include/llvm/ProfileData/ |
| CoverageMapping.h | 68 friend bool operator==(const Counter &LHS, const Counter &RHS) {
69 return LHS.Kind == RHS.Kind && LHS.ID == RHS.ID;
72 friend bool operator!=(const Counter &LHS, const Counter &RHS) {
73 return !(LHS == RHS);
76 friend bool operator<(const Counter &LHS, const Counter &RHS) {
77 return std::tie(LHS.Kind, LHS.ID) < std::tie(RHS.Kind, RHS.ID);
100 Counter LHS, RHS;
102 CounterExpression(ExprKind Kind, Counter LHS, Counter RHS
[all...] |
| /external/llvm/include/llvm/Target/ |
| TargetInstrInfo.h | 466 /// Reg <def>= LHS `Predicate` RHS == ConditionDef
477 MachineOperand LHS;
489 : Predicate(PRED_INVALID), LHS(MachineOperand::CreateImm(0)),
[all...] |
| /external/llvm/lib/CodeGen/SelectionDAG/ |
| LegalizeTypesGeneric.cpp | 138 SDValue LHS = Vals[Slot];
142 std::swap(LHS, RHS);
147 LHS.getValueType().getSizeInBits() << 1),
148 LHS, RHS));
|
| /external/llvm/lib/CodeGen/ |
| TargetLoweringObjectFileImpl.cpp | 749 const MCExpr *LHS =
753 return MCBinaryExpr::createSub(LHS, BSymExpr, Ctx);
757 return MCBinaryExpr::createSub(LHS, RHS, Ctx);
[all...] |
| /external/llvm/lib/Target/Mips/ |
| MipsSEISelDAGToDAG.cpp | 251 SDValue LHS = Node->getOperand(0), RHS = Node->getOperand(1);
252 EVT VT = LHS.getValueType();
274 return CurDAG->SelectNodeTo(Node, MOp, VT, MVT::Glue, LHS,
[all...] |
| /external/clang/lib/CodeGen/ |
| CGExprAgg.cpp | 305 // If the result of the assignment is used, copy the LHS there also.
810 // about the LHS.
866 // If the LHS might be a __block variable, and the RHS can
[all...] |
| /external/clang/lib/Parse/ |
| ParseStmt.cpp | 663 ExprResult LHS;
665 LHS = ParseConstantExpression();
667 LHS = Actions.CorrectDelayedTyposInExpr(LHS, [this](class Expr *E) {
671 if (LHS.isInvalid()) {
681 LHS = Expr;
718 Actions.ActOnCaseStmt(CaseLoc, LHS.get(), DotDotDotLoc,
[all...] |
| /external/clang/lib/Sema/ |
| SemaPseudoObject.cpp | 23 // If it is used as the LHS of a simple assignment, it is treated
26 // If it is used as the LHS of a compound assignment, or the operand
167 Expr *LHS = ce->getLHS(), *RHS = ce->getRHS();
168 Expr *&rebuiltExpr = ce->isConditionTrue() ? LHS : RHS;
173 LHS, RHS,
216 Expr *LHS, Expr *RHS);
286 Expr *LHS, Expr *RHS);
326 Expr *LHS, Expr *RHS);
424 Expr *LHS, Expr *RHS) {
427 Expr *syntacticLHS = rebuildAndCaptureObject(LHS);
1644 Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, cop->getLHS()); local
1654 Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, bop->getLHS()); local
[all...] |
| /external/llvm/examples/Kaleidoscope/Chapter6/ |
| toy.cpp | 160 std::unique_ptr<ExprAST> LHS, RHS;
163 BinaryExprAST(char Op, std::unique_ptr<ExprAST> LHS,
165 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
460 std::unique_ptr<ExprAST> LHS) {
468 return LHS;
480 // the pending operator take RHS as its LHS.
488 // Merge LHS/RHS.
489 LHS =
490 llvm::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS))
[all...] |
| /external/llvm/examples/Kaleidoscope/Chapter7/ |
| toy.cpp | 166 std::unique_ptr<ExprAST> LHS, RHS;
169 BinaryExprAST(char Op, std::unique_ptr<ExprAST> LHS,
171 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
530 std::unique_ptr<ExprAST> LHS) {
538 return LHS;
550 // the pending operator take RHS as its LHS.
558 // Merge LHS/RHS.
559 LHS =
560 llvm::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS))
[all...] |
