| /external/llvm/lib/Analysis/ |
| ScalarEvolutionExpander.cpp | 31 Instruction::CastOps Op,
45 Instruction *NewCI = CastInst::Create(Op, V, Ty, "", IP);
58 Instruction *I = CastInst::Create(Op, V, Ty, V->getName(), IP);
67 Instruction::CastOps Op = CastInst::getCastOpcode(V, false, Ty, false);
68 assert((Op == Instruction::BitCast ||
69 Op == Instruction::PtrToInt ||
70 Op == Instruction::IntToPtr) &&
76 if (Op == Instruction::BitCast && V->getType() == Ty)
80 if ((Op == Instruction::PtrToInt || Op == Instruction::IntToPtr) &
[all...] |
| Loads.cpp | 42 if (const Instruction *BI = dyn_cast<Instruction>(B))
43 if (cast<Instruction>(A)->isIdenticalToWhenDefined(BI))
68 } else if (Operator::getOpcode(V) == Instruction::BitCast) {
86 bool llvm::isSafeToLoadUnconditionally(Value *V, Instruction *ScanFrom,
151 /// instruction before ScanFrom) checking to see if we have the value at the
155 /// If not, return the iterator for the last validated instruction that the
179 Instruction *Inst = --ScanFrom;
223 // If this is some other instruction that may clobber Ptr, bail out.
|
| ValueTracking.cpp | 156 case Instruction::And: {
171 case Instruction::Or: {
185 case Instruction::Xor: {
199 case Instruction::Mul: {
225 case Instruction::UDiv: {
246 case Instruction::Select:
257 case Instruction::FPTrunc:
258 case Instruction::FPExt:
259 case Instruction::FPToUI:
260 case Instruction::FPToSI
[all...] |
| /external/proguard/src/proguard/classfile/editor/ |
| MethodInvocationFixer.java | 28 import proguard.classfile.instruction.*;
29 import proguard.classfile.instruction.visitor.InstructionVisitor;
78 public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {}
102 // Replace the invocation by an invokestatic instruction.
103 Instruction replacementInstruction =
123 // Replace the invocation by an invokespecial instruction.
124 Instruction replacementInstruction =
149 Instruction replacementInstruction =
173 // Replace the invocation by an invokevirtual instruction
[all...] |
| CodeAttributeEditor.java | 28 import proguard.classfile.instruction.*;
29 import proguard.classfile.instruction.visitor.InstructionVisitor;
62 /*private*/public Instruction[] preInsertions = new Instruction[ClassConstants.TYPICAL_CODE_LENGTH];
63 /*private*/public Instruction[] replacements = new Instruction[ClassConstants.TYPICAL_CODE_LENGTH];
64 /*private*/public Instruction[] postInsertions = new Instruction[ClassConstants.TYPICAL_CODE_LENGTH];
101 preInsertions = new Instruction[codeLength];
102 replacements = new Instruction[codeLength]
562 Instruction instruction = InstructionFactory.create(oldCode, oldOffset); local
644 Instruction instruction = InstructionFactory.create(oldCode, oldOffset); local
1097 Instruction instruction = instructions[index]; local
1140 Instruction instruction = instructions[index]; local
[all...] |
| /external/llvm/lib/Target/CBackend/ |
| CBackend.cpp | 185 void writeInstComputationInline(Instruction &I);
189 bool writeInstructionCast(const Instruction &I);
233 static bool isInlinableInst(const Instruction &I) {
250 const Instruction &User = cast<Instruction>(*I.use_back());
256 // Only inline instruction it if it's use is in the same BB as the inst.
257 return I.getParent() == cast<Instruction>(I.use_back())->getParent();
274 // isInlineAsm - Check if the instruction is a call to an inline asm chunk.
275 static bool isInlineAsm(const Instruction& I) {
281 // Instruction visitation function
[all...] |
| /external/llvm/lib/Bitcode/Writer/ |
| ValueEnumerator.h | 26 class Instruction;
62 typedef DenseMap<const Instruction*, unsigned> InstructionMapType;
94 unsigned getInstructionID(const Instruction *I) const;
95 void setInstructionID(const Instruction *I);
|
| /external/llvm/lib/Transforms/Scalar/ |
| SCCP.cpp | 72 /// overdefined - This instruction is not known to be constant, and we know
206 std::multimap<PHINode*, Instruction*> UsersOfOverdefinedPHIs;
314 // is not already a constant, add it to the instruction work list so that
315 // the users of the instruction are updated later.
344 // value is not already overdefined, add it to the overdefined instruction
345 // work list so that the users of the instruction are updated later.
452 // successors are reachable from a given terminator instruction.
462 // instruction that was just changed state somehow. Based on this
463 // information, we need to update the specified user of this instruction.
465 void OperandChangedState(Instruction *I)
[all...] |
| CodeGenPrepare.cpp | 76 /// next instruction to optimize. Xforms that can invalidate this should
107 bool OptimizeInst(Instruction *I);
108 bool OptimizeMemoryInst(Instruction *I, Value *Addr, Type *AccessTy);
111 bool MoveExtToFormExtLoad(Instruction *I);
112 bool OptimizeExtUses(Instruction *I);
186 // If the instruction before the branch (skipping debug info) isn't a phi
226 const Instruction *User = cast<Instruction>(*UI);
235 Instruction *Insn = dyn_cast<Instruction>(UPN->getIncomingValue(I))
[all...] |
| ObjCARC.cpp | 275 if (const Instruction *I = dyn_cast<Instruction>(V)) {
276 // Any instruction other than bitcast and gep with a pointer operand have a
283 case Instruction::Call: {
314 case Instruction::Invoke:
316 case Instruction::BitCast:
317 case Instruction::GetElementPtr:
318 case Instruction::Select: case Instruction::PHI:
319 case Instruction::Ret: case Instruction::Br
[all...] |
| /external/proguard/src/proguard/classfile/instruction/ |
| SwitchInstruction.java | 21 package proguard.classfile.instruction;
24 * This Instruction represents a simple instruction without variable arguments
29 public abstract class SwitchInstruction extends Instruction
55 * Copies the given instruction into this instruction.
56 * @param switchInstruction the instruction to be copied.
57 * @return this instruction.
69 // Implementations for Instruction.
|
| /frameworks/compile/slang/BitWriter_2_9/ |
| ValueEnumerator.h | 26 class Instruction;
62 typedef DenseMap<const Instruction*, unsigned> InstructionMapType;
94 unsigned getInstructionID(const Instruction *I) const;
95 void setInstructionID(const Instruction *I);
|
| /external/llvm/lib/VMCore/ |
| ConstantFold.cpp | 38 // ConstantFold*Instruction Implementations
90 Instruction::CastOps firstOp = Instruction::CastOps(Op->getOpcode());
91 Instruction::CastOps secondOp = Instruction::CastOps(opc);
104 // the first element. If so, return the appropriate GEP instruction.
220 case Instruction::Or: {
235 case Instruction::And: {
249 case Instruction::LShr: {
271 case Instruction::Shl:
[all...] |
| ConstantsContext.h | 76 : ConstantExpr(C2->getType(), Instruction::Select, &Op<0>(), 3) {
97 Instruction::ExtractElement, &Op<0>(), 2) {
116 : ConstantExpr(C1->getType(), Instruction::InsertElement,
140 Instruction::ShuffleVector,
163 : ConstantExpr(DestTy, Instruction::ExtractValue, &Op<0>(), 1),
188 : ConstantExpr(DestTy, Instruction::InsertValue, &Op<0>(), 2),
231 CompareConstantExpr(Type *ty, Instruction::OtherOps opc,
412 if (Instruction::isCast(V.opcode))
414 if ((V.opcode >= Instruction::BinaryOpsBegin &&
415 V.opcode < Instruction::BinaryOpsEnd)
[all...] |
| Dominators.cpp | 85 bool DominatorTree::dominates(const Instruction *A, const Instruction *B) const{
88 // If A is an invoke instruction, its value is only available in this normal
|
| /external/llvm/lib/Transforms/InstCombine/ |
| InstructionCombining.cpp | 124 Instruction::BinaryOps Opcode = I.getOpcode();
125 if (Opcode != Instruction::Add &&
126 Opcode != Instruction::Sub) {
141 if (Opcode == Instruction::Add) {
172 Instruction::BinaryOps Opcode = I.getOpcode();
312 static bool LeftDistributesOverRight(Instruction::BinaryOps LOp,
313 Instruction::BinaryOps ROp) {
318 case Instruction::And:
323 case Instruction::Or:
324 case Instruction::Xor
[all...] |
| InstCombinePHI.cpp | 24 Instruction *InstCombiner::FoldPHIArgBinOpIntoPHI(PHINode &PN) {
25 Instruction *FirstInst = cast<Instruction>(PN.getIncomingValue(0));
45 Instruction *I = dyn_cast<Instruction>(PN.getIncomingValue(i));
101 Instruction *InInst = cast<Instruction>(PN.getIncomingValue(i));
130 Instruction *InstCombiner::FoldPHIArgGEPIntoPHI(PHINode &PN) {
287 Instruction *InstCombiner::FoldPHIArgLoadIntoPHI(PHINode &PN) {
391 Instruction *InstCombiner::FoldPHIArgOpIntoPHI(PHINode &PN)
[all...] |
| /external/llvm/include/llvm/Transforms/Utils/ |
| ValueMapper.h | 22 class Instruction;
42 /// only local values within a function (such as an instruction or argument)
60 void RemapInstruction(Instruction *I, ValueToValueMapTy &VM,
|
| /external/llvm/tools/opt/ |
| AnalysisWrappers.cpp | 42 Instruction *User = dyn_cast<Instruction>(*UI);
|
| /external/proguard/src/proguard/optimize/peephole/ |
| InstructionSequenceReplacer.java | 28 import proguard.classfile.instruction.*;
29 import proguard.classfile.instruction.visitor.InstructionVisitor;
33 * This InstructionVisitor replaces a given pattern instruction sequence by
34 * another given replacement instruction sequence. The arguments of the
35 * instruction sequences can be wildcards that are matched and replaced.
49 private final Instruction[] replacementInstructions;
60 * instruction.
61 * @param patternInstructions the pattern instruction sequence.
62 * @param replacementInstructions the replacement instruction sequence.
70 Instruction[] patternInstructions
[all...] |
| GotoCommonCodeReplacer.java | 27 import proguard.classfile.instruction.*;
28 import proguard.classfile.instruction.visitor.InstructionVisitor;
94 public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {}
99 // Check if the instruction is an unconditional goto instruction that
126 codeAttributeEditor.replaceInstruction( deleteOffset, (Instruction)null);
127 codeAttributeEditor.insertBeforeInstruction(deleteOffset, (Instruction)null);
128 codeAttributeEditor.insertAfterInstruction( deleteOffset, (Instruction)null);
134 // Redirect the goto instruction, if it is still necessary
[all...] |
| /external/webkit/Source/JavaScriptCore/jit/ |
| JITOpcodes32_64.cpp | 475 void JIT::emit_op_mov(Instruction* currentInstruction)
489 void JIT::emit_op_end(Instruction* currentInstruction)
497 void JIT::emit_op_jmp(Instruction* currentInstruction)
503 void JIT::emit_op_loop_if_lesseq(Instruction* currentInstruction)
531 void JIT::emitSlow_op_loop_if_lesseq(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
548 void JIT::emit_op_new_object(Instruction* currentInstruction)
553 void JIT::emit_op_check_has_instance(Instruction* currentInstruction)
567 void JIT::emit_op_instanceof(Instruction* currentInstruction)
614 void JIT::emitSlow_op_check_has_instance(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
626 void JIT::emitSlow_op_instanceof(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter
[all...] |
| /external/v8/src/mips/ |
| constants-mips.cc | 148 // Instruction
150 bool Instruction::IsForbiddenInBranchDelay() const {
190 bool Instruction::IsLinkingInstruction() const {
215 bool Instruction::IsTrap() const {
235 Instruction::Type Instruction::InstructionType() const {
|
| /external/llvm/include/llvm/Analysis/ |
| AliasSetTracker.h | 115 std::vector<AssertingVH<Instruction> > UnknownInsts;
150 Instruction *getUnknownInst(unsigned i) const {
256 void addUnknownInst(Instruction *I, AliasAnalysis &AA);
257 void removeUnknownInst(Instruction *I) {
272 bool aliasesUnknownInst(Instruction *Inst, AliasAnalysis &AA) const;
314 /// instructions to the alias sets. Adding a new instruction can result in
317 /// 1. If the instruction doesn't alias any other sets, create a new set.
318 /// 2. If the instruction aliases exactly one set, add it to the set
319 /// 3. If the instruction aliases multiple sets, merge the sets, and add
320 /// the instruction to the result
[all...] |
| /external/llvm/lib/Transforms/IPO/ |
| FunctionAttrs.cpp | 122 Instruction *I = &*II;
125 // Detect these now, skipping to the next instruction if one is found.
192 // If this instruction may read memory, remember that.
280 if (Instruction *RVI = dyn_cast<Instruction>(RetVal))
283 case Instruction::BitCast:
284 case Instruction::GetElementPtr:
287 case Instruction::Select: {
293 case Instruction::PHI: {
301 case Instruction::Alloca
[all...] |
