| /external/clang/include/clang/Edit/ |
| FileOffset.h | 37 friend bool operator==(FileOffset LHS, FileOffset RHS) {
38 return LHS.FID == RHS.FID && LHS.Offs == RHS.Offs;
40 friend bool operator!=(FileOffset LHS, FileOffset RHS) {
41 return !(LHS == RHS);
43 friend bool operator<(FileOffset LHS, FileOffset RHS) {
44 if (LHS.FID != RHS.FID)
45 return LHS.FID < RHS.FID;
46 return LHS.Offs < RHS.Offs;
48 friend bool operator>(FileOffset LHS, FileOffset RHS)
[all...] |
| /external/clang/include/clang/Basic/ |
| ABI.h | 50 friend bool operator==(const ReturnAdjustment &LHS,
52 return LHS.NonVirtual == RHS.NonVirtual &&
53 LHS.VBaseOffsetOffset == RHS.VBaseOffsetOffset;
56 friend bool operator<(const ReturnAdjustment &LHS,
58 if (LHS.NonVirtual < RHS.NonVirtual)
61 return LHS.NonVirtual == RHS.NonVirtual &&
62 LHS.VBaseOffsetOffset < RHS.VBaseOffsetOffset;
80 friend bool operator==(const ThisAdjustment &LHS,
82 return LHS.NonVirtual == RHS.NonVirtual &&
83 LHS.VCallOffsetOffset == RHS.VCallOffsetOffset
[all...] |
| /external/llvm/include/llvm/Support/ |
| NoFolder.h | 40 Instruction *CreateAdd(Constant *LHS, Constant *RHS,
42 BinaryOperator *BO = BinaryOperator::CreateAdd(LHS, RHS);
47 Instruction *CreateNSWAdd(Constant *LHS, Constant *RHS) const {
48 return BinaryOperator::CreateNSWAdd(LHS, RHS);
50 Instruction *CreateNUWAdd(Constant *LHS, Constant *RHS) const {
51 return BinaryOperator::CreateNUWAdd(LHS, RHS);
53 Instruction *CreateFAdd(Constant *LHS, Constant *RHS) const {
54 return BinaryOperator::CreateFAdd(LHS, RHS);
56 Instruction *CreateSub(Constant *LHS, Constant *RHS,
58 BinaryOperator *BO = BinaryOperator::CreateSub(LHS, RHS)
[all...] |
| PatternMatch.h | 297 BinaryOp_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
312 template<typename LHS, typename RHS>
313 inline BinaryOp_match<LHS, RHS, Instruction::Add>
314 m_Add(const LHS &L, const RHS &R) {
315 return BinaryOp_match<LHS, RHS, Instruction::Add>(L, R);
318 template<typename LHS, typename RHS>
319 inline BinaryOp_match<LHS, RHS, Instruction::FAdd>
320 m_FAdd(const LHS &L, const RHS &R) {
321 return BinaryOp_match<LHS, RHS, Instruction::FAdd>(L, R)
[all...] |
| ConstantFolder.h | 34 Constant *CreateAdd(Constant *LHS, Constant *RHS,
36 return ConstantExpr::getAdd(LHS, RHS, HasNUW, HasNSW);
38 Constant *CreateFAdd(Constant *LHS, Constant *RHS) const {
39 return ConstantExpr::getFAdd(LHS, RHS);
41 Constant *CreateSub(Constant *LHS, Constant *RHS,
43 return ConstantExpr::getSub(LHS, RHS, HasNUW, HasNSW);
45 Constant *CreateFSub(Constant *LHS, Constant *RHS) const {
46 return ConstantExpr::getFSub(LHS, RHS);
48 Constant *CreateMul(Constant *LHS, Constant *RHS,
50 return ConstantExpr::getMul(LHS, RHS, HasNUW, HasNSW)
[all...] |
| TargetFolder.h | 50 Constant *CreateAdd(Constant *LHS, Constant *RHS,
52 return Fold(ConstantExpr::getAdd(LHS, RHS, HasNUW, HasNSW));
54 Constant *CreateFAdd(Constant *LHS, Constant *RHS) const {
55 return Fold(ConstantExpr::getFAdd(LHS, RHS));
57 Constant *CreateSub(Constant *LHS, Constant *RHS,
59 return Fold(ConstantExpr::getSub(LHS, RHS, HasNUW, HasNSW));
61 Constant *CreateFSub(Constant *LHS, Constant *RHS) const {
62 return Fold(ConstantExpr::getFSub(LHS, RHS));
64 Constant *CreateMul(Constant *LHS, Constant *RHS,
66 return Fold(ConstantExpr::getMul(LHS, RHS, HasNUW, HasNSW))
[all...] |
| IRBuilder.h | 506 Value *LHS, Value *RHS,
509 BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
523 Value *CreateAdd(Value *LHS, Value *RHS, const Twine &Name = "",
525 if (Constant *LC = dyn_cast<Constant>(LHS))
528 return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name,
531 Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
532 return CreateAdd(LHS, RHS, Name, false, true);
534 Value *CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
535 return CreateAdd(LHS, RHS, Name, true, false);
537 Value *CreateFAdd(Value *LHS, Value *RHS, const Twine &Name = ""
[all...] |
| /external/llvm/include/llvm/ADT/ |
| Twine.h | 150 /// LHS - The prefix in the concatenation, which may be uninitialized for
152 Child LHS;
173 LHS.twine = &_LHS;
181 : LHS(_LHS), RHS(_RHS), LHSKind(_LHSKind), RHSKind(_RHSKind) {
221 // The RHS cannot be non-empty if the LHS is empty.
227 !LHS.twine->isBinary())
266 LHS.cString = Str;
277 LHS.stdString = &Str;
284 LHS.stringRef = &Str;
291 LHS.character = Val
[all...] |
| DenseMapInfo.h | 27 //static bool isEqual(const T &LHS, const T &RHS);
47 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
55 static bool isEqual(const char &LHS, const char &RHS) {
56 return LHS == RHS;
65 static bool isEqual(const unsigned& LHS, const unsigned& RHS) {
66 return LHS == RHS;
77 static bool isEqual(const unsigned long& LHS, const unsigned long& RHS) {
78 return LHS == RHS;
89 static bool isEqual(const unsigned long long& LHS,
[all...] |
| Triple.h | 252 unsigned LHS[3];
253 getOSVersion(LHS[0], LHS[1], LHS[2]);
255 if (LHS[0] != Major)
256 return LHS[0] < Major;
257 if (LHS[1] != Minor)
258 return LHS[1] < Minor;
259 if (LHS[2] != Micro)
260 return LHS[1] < Micro
[all...] |
| /frameworks/native/include/utils/ |
| Debug.h | 39 template<typename LHS, typename RHS>
40 struct CompileTimeIfElse<true, LHS, RHS> { typedef LHS TYPE; };
41 template<typename LHS, typename RHS>
42 struct CompileTimeIfElse<false, LHS, RHS> { typedef RHS TYPE; };
|
| /external/llvm/include/llvm/MC/ |
| MCExpr.h | 333 const MCExpr *LHS, *RHS;
336 : MCExpr(MCExpr::Binary), Op(_Op), LHS(_LHS), RHS(_RHS) {}
342 static const MCBinaryExpr *Create(Opcode Op, const MCExpr *LHS,
344 static const MCBinaryExpr *CreateAdd(const MCExpr *LHS, const MCExpr *RHS,
346 return Create(Add, LHS, RHS, Ctx);
348 static const MCBinaryExpr *CreateAnd(const MCExpr *LHS, const MCExpr *RHS,
350 return Create(And, LHS, RHS, Ctx);
352 static const MCBinaryExpr *CreateDiv(const MCExpr *LHS, const MCExpr *RHS,
354 return Create(Div, LHS, RHS, Ctx);
356 static const MCBinaryExpr *CreateEQ(const MCExpr *LHS, const MCExpr *RHS
[all...] |
| /external/clang/test/SemaCXX/ |
| warn-self-assign.cpp | 18 #define LHS a
23 LHS = a;
25 LHS OP RHS;
27 #undef LHS
|
| /external/clang/include/clang/AST/ |
| BaseSubobject.h | 46 friend bool operator==(const BaseSubobject &LHS, const BaseSubobject &RHS) {
47 return LHS.Base == RHS.Base && LHS.BaseOffset == RHS.BaseOffset;
74 static bool isEqual(const clang::BaseSubobject &LHS,
76 return LHS == RHS;
|
| TypeOrdering.h | 51 static bool isEqual(clang::QualType LHS, clang::QualType RHS) {
52 return LHS == RHS;
71 static bool isEqual(clang::CanQualType LHS, clang::CanQualType RHS) {
72 return LHS == RHS;
|
| DeclarationName.h | 266 friend bool operator==(DeclarationName LHS, DeclarationName RHS) {
267 return LHS.Ptr == RHS.Ptr;
271 friend bool operator!=(DeclarationName LHS, DeclarationName RHS) {
272 return LHS.Ptr != RHS.Ptr;
283 static int compare(DeclarationName LHS, DeclarationName RHS);
290 inline bool operator<(DeclarationName LHS, DeclarationName RHS) {
291 return DeclarationName::compare(LHS, RHS) < 0;
296 inline bool operator>(DeclarationName LHS, DeclarationName RHS) {
297 return DeclarationName::compare(LHS, RHS) > 0;
302 inline bool operator<=(DeclarationName LHS, DeclarationName RHS)
[all...] |
| /external/llvm/lib/CodeGen/ |
| MachineModuleInfoImpls.cpp | 27 static int SortSymbolPair(const void *LHS, const void *RHS) {
29 const MCSymbol *LHSS = ((const PairTy *)LHS)->first;
|
| /external/llvm/include/llvm/Analysis/ |
| InstructionSimplify.h | 34 Value *SimplifyAddInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW,
41 Value *SimplifySubInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW,
48 Value *SimplifyMulInst(Value *LHS, Value *RHS, const TargetData *TD = 0,
54 Value *SimplifySDivInst(Value *LHS, Value *RHS, const TargetData *TD = 0,
60 Value *SimplifyUDivInst(Value *LHS, Value *RHS, const TargetData *TD = 0,
66 Value *SimplifyFDivInst(Value *LHS, Value *RHS, const TargetData *TD = 0,
72 Value *SimplifySRemInst(Value *LHS, Value *RHS, const TargetData *TD = 0,
78 Value *SimplifyURemInst(Value *LHS, Value *RHS, const TargetData *TD = 0,
84 Value *SimplifyFRemInst(Value *LHS, Value *RHS, const TargetData *TD = 0,
111 Value *SimplifyAndInst(Value *LHS, Value *RHS, const TargetData *TD = 0
[all...] |
| /external/llvm/include/llvm/Transforms/Utils/ |
| CmpInstAnalysis.h | 56 Value *getICmpValue(bool Sign, unsigned Code, Value *LHS, Value *RHS,
|
| /external/clang/lib/Lex/ |
| PPExpressions.cpp | 56 static bool EvaluateDirectiveSubExpr(PPValue &LHS, unsigned MinPrec,
434 /// PeekTok, and whose precedence is PeekPrec. This returns the result in LHS.
439 static bool EvaluateDirectiveSubExpr(PPValue &LHS, unsigned MinPrec,
446 << LHS.getRange();
464 if (Operator == tok::ampamp && LHS.Val == 0)
466 else if (Operator == tok::pipepipe && LHS.Val != 0)
468 else if (Operator == tok::question && LHS.Val == 0)
477 PPValue RHS(LHS.getBitWidth());
499 // the LHS of the '?'. The grammar rule is:
520 llvm::APSInt Res(LHS.getBitWidth())
[all...] |
| /external/llvm/utils/TableGen/ |
| DAGISelEmitter.cpp | 61 // PatternSortingPredicate - return true if we prefer to match LHS before RHS.
68 bool operator()(const PatternToMatch *LHS, const PatternToMatch *RHS) {
69 const TreePatternNode *LHSSrc = LHS->getSrcPattern();
85 unsigned LHSSize = LHS->getPatternComplexity(CGP);
87 if (LHSSize > RHSSize) return true; // LHS -> bigger -> less cost
91 unsigned LHSCost = getResultPatternCost(LHS->getDstPattern(), CGP);
96 unsigned LHSPatSize = getResultPatternSize(LHS->getDstPattern(), CGP);
103 assert(LHS == RHS || LHS->ID != RHS->ID);
104 return LHS->ID < RHS->ID
[all...] |
| /external/llvm/lib/Transforms/Utils/ |
| CmpInstAnalysis.cpp | 72 Value *llvm::getICmpValue(bool Sign, unsigned Code, Value *LHS, Value *RHS,
77 return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0);
85 return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 1);
|
| /external/llvm/lib/Transforms/InstCombine/ |
| InstCombineAndOrXor.cpp | 97 static Value *getNewICmpValue(bool Sign, unsigned Code, Value *LHS, Value *RHS,
100 if (Value *NewConstant = getICmpValue(Sign, Code, LHS, RHS, NewPred))
102 return Builder->CreateICmp(NewPred, LHS, RHS);
109 Value *LHS, Value *RHS,
122 if (!isordered) return ConstantInt::getTrue(LHS->getContext());
125 return Builder->CreateFCmp(Pred, LHS, RHS);
334 /// FoldLogicalPlusAnd - This is part of an expression (LHS +/- RHS) & Mask,
344 Value *InstCombiner::FoldLogicalPlusAnd(Value *LHS, Value *RHS,
347 Instruction *LHSI = dyn_cast<Instruction>(LHS);
533 /// that both LHS and RHS satisf
[all...] |
| InstCombineAddSub.cpp | 61 /// (sext (add LHS, RHS)) === (add (sext LHS), (sext RHS))
64 bool InstCombiner::WillNotOverflowSignedAdd(Value *LHS, Value *RHS) {
69 // have one carry bit which can change a sign. As such, if LHS and RHS each
72 if (ComputeNumSignBits(LHS) > 1 && ComputeNumSignBits(RHS) > 1)
88 Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
90 if (Value *V = SimplifyAddInst(LHS, RHS, I.hasNoSignedWrap(),
102 return BinaryOperator::CreateXor(LHS, RHS);
110 if (ZExtInst *ZI = dyn_cast<ZExtInst>(LHS))
115 if (match(LHS, m_Xor(m_Value(XorLHS), m_ConstantInt(XorRHS))))
[all...] |
| /external/llvm/lib/Analysis/ |
| InstructionSimplify.cpp | 78 /// isSameCompare - Is V equivalent to the comparison "LHS Pred RHS"?
79 static bool isSameCompare(Value *V, CmpInst::Predicate Pred, Value *LHS,
86 if (CPred == Pred && CLHS == LHS && CRHS == RHS)
89 CRHS == LHS;
125 /// given by OpcodeToExpand, while "A" corresponds to LHS and "B op' C" to RHS.
128 static Value *ExpandBinOp(unsigned Opcode, Value *LHS, Value *RHS,
137 if (BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS))
145 // If "L op' R" equals "A op' B" then "L op' R" is just the LHS.
149 return LHS;
163 Value *A = LHS, *B = Op1->getOperand(0), *C = Op1->getOperand(1)
[all...] |
