Searched refs:Fold (Results 1 - 12 of 12) sorted by relevance

/external/llvm/include/llvm/Analysis/
H A DTargetFolder.h35 /// Fold - Fold the constant using target specific information.
36 Constant *Fold(Constant *C) const { function in class:llvm::TargetFolder
52 return Fold(ConstantExpr::getAdd(LHS, RHS, HasNUW, HasNSW));
55 return Fold(ConstantExpr::getFAdd(LHS, RHS));
59 return Fold(ConstantExpr::getSub(LHS, RHS, HasNUW, HasNSW));
62 return Fold(ConstantExpr::getFSub(LHS, RHS));
66 return Fold(ConstantExpr::getMul(LHS, RHS, HasNUW, HasNSW));
69 return Fold(ConstantExpr::getFMul(LHS, RHS));
72 return Fold(ConstantExp
[all...]
/external/llvm/lib/Target/AMDGPU/
H A DSIFoldOperands.cpp1 //===-- SIFoldOperands.cpp - Fold operands --- ----------------------------===//
43 return "SI Fold Operands";
80 "SI Fold Operands", false, false)
83 "SI Fold Operands", false, false)
107 static bool updateOperand(FoldCandidate &Fold, argument
109 MachineInstr *MI = Fold.UseMI;
110 MachineOperand &Old = MI->getOperand(Fold.UseOpNo);
113 if (Fold.isImm()) {
114 Old.ChangeToImmediate(Fold.ImmToFold);
118 MachineOperand *New = Fold
[all...]
/external/llvm/lib/TableGen/
H A DRecord.cpp587 Resolved = OResolved->Fold(&R, nullptr);
617 Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { function in class:UnOpInit
719 return (UnOpInit::get(getOpcode(), lhs, getType()))->Fold(&R, nullptr);
720 return Fold(&R, nullptr);
751 Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { function in class:BinOpInit
847 return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))->Fold(&R,nullptr);
848 return Fold(&R, nullptr);
918 Init *NewVal = NewOp->Fold(CurRec, CurMultiClass);
976 Init *NewItem = NewOp->Fold(CurRec, CurMultiClass);
985 Init *TernOpInit::Fold(Recor function in class:TernOpInit
[all...]
H A DTGParser.cpp873 return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec, CurMultiClass);
954 ->Fold(CurRec, CurMultiClass);
961 ->Fold(CurRec, CurMultiClass);
1082 return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec,
1583 StringRecTy::get())->Fold(CurRec, CurMultiClass);
2344 StringRecTy::get())->Fold(DefProto, &MC),
2345 DefName, StringRecTy::get())->Fold(DefProto, &MC);
/external/llvm/lib/Transforms/InstCombine/
H A DInstCombineMulDivRem.cpp1276 Constant *Fold = nullptr; local
1282 Fold = ConstantExpr::getFDiv(C1, C2);
1285 Fold = ConstantExpr::getFMul(C1, C2);
1288 Fold = ConstantExpr::getFDiv(C1, C2);
1292 if (Fold && isNormalFp(Fold)) {
1293 Instruction *R = CreateDiv ? BinaryOperator::CreateFDiv(Fold, X)
1294 : BinaryOperator::CreateFMul(X, Fold);
/external/llvm/lib/Transforms/Utils/
H A DLoopUnroll.cpp478 if (BasicBlock *Fold = FoldBlockIntoPredecessor(Dest, LI, SE,
480 std::replace(Latches.begin(), Latches.end(), Dest, Fold);
/external/llvm/include/llvm/TableGen/
H A DRecord.h666 // Fold - If possible, fold this to a simpler init. Return this if not
668 virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0;
714 // Fold - If possible, fold this to a simpler init. Return this if not
716 Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const override;
766 // Fold - If possible, fold this to a simpler init. Return this if not
768 Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const override;
823 // Fold - If possible, fold this to a simpler init. Return this if not
825 Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const override;
/external/llvm/lib/Analysis/
H A DScalarEvolution.cpp1081 // Fold if the operand is constant.
1411 // Fold if the operand is constant.
1589 // Fold if the operand is constant.
2098 const SCEV *Fold = getAddExpr(LargeOps, Flags); variable
2100 if (isa<SCEVConstant>(Fold) || isa<SCEVUnknown>(Fold))
2101 return getTruncateExpr(Fold, DstType);
2180 // Fold W + X + (X * Y * Z) --> W + (X * ((Y*Z)+1))
2215 // Fold X + (A*B*C) + (A*D*E) --> X + (A*(B*C+D*E))
2431 ConstantInt *Fold
[all...]
/external/clang/test/SemaCXX/
H A Dconstant-expression-cxx11.cpp1376 namespace Fold {
/external/clang/lib/AST/
H A DExprConstant.cpp491 /// Fold the expression to a constant. Stop if we hit a side-effect that
4171 FoldConstant Fold(Info, IsBcpCall);
4173 Fold.keepDiagnostics();
6445 FoldOffsetRAII Fold(Info, Type & 1);
/external/llvm/lib/CodeGen/SelectionDAG/
H A DSelectionDAG.cpp3005 if (SDValue Fold = FoldConstantVectorArithmetic(Opcode, DL, VT, Ops))
3006 return Fold;
3289 // Fold one vector element.
3424 // Fold trivial token factors.
3826 // Fold a bunch of operators when the RHS is undef.
3973 // Fold bit_convert nodes from a type to themselves.
H A DDAGCombiner.cpp3184 // Fold the AND away, taking care not to fold to the old load node if we
3747 // Fold this sequence only if the resulting shuffle is 'legal'.
4301 // Fold the constants, shifting the binop RHS by the shift amount.
5637 // Fold (vselect (build_vector all_ones), N1, N2) -> N1
5640 // Fold (vselect (build_vector all_zeros), N1, N2) -> N2
5685 // Fold to a simpler select_cc
6312 // Fold (zext (and (trunc x), cst)) -> (and x, cst),
6563 // Fold (aext (and (trunc x), cst)) -> (and x, cst)
7042 // Fold extract-and-trunc into a narrow extract. For example:
7094 // Fold
[all...]

Completed in 451 milliseconds