| /external/proguard/src/proguard/optimize/peephole/ |
| UnreachableCodeRemover.java | 27 import proguard.classfile.instruction.Instruction;
28 import proguard.classfile.instruction.visitor.InstructionVisitor;
123 public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction)
127 System.out.println(" "+(reachableCodeMarker.isReachable(offset) ? "+" : "-")+" "+instruction.toString(offset));
130 // Is this instruction unreachable?
136 // Visit the instruction, if required.
139 instruction.accept(clazz, method, codeAttribute, offset, extraInstructionVisitor);
|
| ReachableCodeMarker.java | 26 import proguard.classfile.instruction.*;
27 import proguard.classfile.instruction.visitor.InstructionVisitor;
31 * This AttributeVisitor finds all instruction offsets, branch targets, and
49 * Returns whether the instruction at the given offset is reachable in
200 * Marks the branch targets of the given jump offsets for the instruction
234 // Continue with the current instruction as long as we haven't marked it
238 // Get the current instruction.
239 Instruction instruction = InstructionFactory.create(code, offset); local
245 // instruction in a moment
[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/proguard/src/proguard/preverify/ |
| CodeSubroutineInliner.java | 27 import proguard.classfile.instruction.*;
28 import proguard.classfile.instruction.visitor.InstructionVisitor;
118 Instruction instruction = InstructionFactory.create(codeAttribute.code, offset); local
119 int instructionLength = instruction.length(offset);
128 System.out.println(" Skipping original subroutine instruction "+instruction.toString(offset));
136 // Copy the instruction, inlining any subroutine call recursively.
137 instruction.accept(clazz, method, codeAttribute, offset, this);
245 public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction
362 Instruction instruction = InstructionFactory.create(codeAttribute.code, offset); local
[all...] |
| /external/v8/src/arm/ |
| simulator-arm.h | 155 // instruction.
216 void Format(Instruction* instr, const char* format);
218 // Checks if the current instruction should be executed based on its
220 bool ConditionallyExecute(Instruction* instr);
238 int32_t GetShiftRm(Instruction* instr, bool* carry_out);
239 int32_t GetImm(Instruction* instr, bool* carry_out);
240 void ProcessPUW(Instruction* instr,
245 void HandleRList(Instruction* instr, bool load);
246 void HandleVList(Instruction* inst);
247 void SoftwareInterrupt(Instruction* instr)
[all...] |
| /external/llvm/include/llvm/Analysis/ |
| IVUsers.h | 25 class Instruction;
35 /// instruction of the operand, and 'OperandValToReplace' is the operand of
40 IVStrideUse(IVUsers *P, Instruction* U, Value *O)
44 /// getUser - Return the user instruction for this use.
45 Instruction *getUser() const {
46 return cast<Instruction>(getValPtr());
49 /// setUser - Assign a new user instruction for this use.
50 void setUser(Instruction *NewUser) {
55 /// instruction that this IVStrideUse is representing.
80 /// OperandValToReplace - The Value of the operand in the user instruction
[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...] |
| /external/proguard/src/proguard/optimize/evaluation/ |
| PartialEvaluator.java | 27 import proguard.classfile.instruction.*;
217 // Find all instruction offsets,...
220 // Start executing the first instruction block.
246 Instruction instruction = InstructionFactory.create(codeAttribute.code, local
248 System.out.println(instruction.toString(offset));
274 offset += instruction.length(offset);
299 * Returns whether the instruction at the given offset has ever been
309 * Returns whether there is an instruction at the given offset.
318 * Returns whether the instruction at the given offset is the target of
709 Instruction instruction = InstructionFactory.create(code, instructionOffset); local
[all...] |
| /external/proguard/src/proguard/classfile/instruction/ |
| InstructionFactory.java | 21 package proguard.classfile.instruction;
24 * This class provides methods to create and reuse Instruction objects.
31 * Creates a new Instruction from the data in the byte array, starting
34 public static Instruction create(byte[] code, int offset)
36 Instruction instruction; local
168 instruction = new SimpleInstruction();
191 instruction = new ConstantInstruction();
250 instruction = new VariableInstruction(wide);
276 instruction = new BranchInstruction()
[all...] |
| /external/proguard/src/proguard/classfile/util/ |
| DynamicMemberReferenceInitializer.java | 28 import proguard.classfile.instruction.*;
29 import proguard.classfile.instruction.visitor.InstructionVisitor;
109 private final Instruction[] CONSTANT_GET_FIELD_INSTRUCTIONS = new Instruction[]
117 private final Instruction[] CONSTANT_GET_METHOD_INSTRUCTIONS0 = new Instruction[]
127 private final Instruction[] CONSTANT_GET_METHOD_INSTRUCTIONS1 = new Instruction[]
141 private final Instruction[] CONSTANT_GET_METHOD_INSTRUCTIONS2 = new Instruction[]
[all...] |
| /external/llvm/include/llvm/Support/ |
| PatternMatch.h | 24 // This is primarily useful to things like the instruction combiner, but can
291 inline BinaryOp_match<LHS, RHS, Instruction::Add>
293 return BinaryOp_match<LHS, RHS, Instruction::Add>(L, R);
297 inline BinaryOp_match<LHS, RHS, Instruction::FAdd>
299 return BinaryOp_match<LHS, RHS, Instruction::FAdd>(L, R);
303 inline BinaryOp_match<LHS, RHS, Instruction::Sub>
305 return BinaryOp_match<LHS, RHS, Instruction::Sub>(L, R);
309 inline BinaryOp_match<LHS, RHS, Instruction::FSub>
311 return BinaryOp_match<LHS, RHS, Instruction::FSub>(L, R);
315 inline BinaryOp_match<LHS, RHS, Instruction::Mul
[all...] |
| /external/llvm/tools/llvm-diff/ |
| DiffLog.cpp | 34 void DiffLogBuilder::addMatch(Instruction *L, Instruction *R) {
37 void DiffLogBuilder::addLeft(Instruction *L) {
41 void DiffLogBuilder::addRight(Instruction *R) {
52 Instruction *DiffLogBuilder::getLeft(unsigned I) const { return Diff[I].first; }
53 Instruction *DiffLogBuilder::getRight(unsigned I) const { return Diff[I].second; }
|
| /external/webkit/LayoutTests/fast/xpath/py-dom-xpath/ |
| data.html | 15 ' <?processing instruction ?>' +
41 test(doc, doc.documentElement, 'string(//processing-instruction())', 'instruction ', nsResolver);
42 test(doc, doc.documentElement, 'name(//processing-instruction())', 'processing', nsResolver);
43 test(doc, doc.documentElement, 'local-name(//processing-instruction())', 'processing', nsResolver);
44 test(doc, doc.documentElement, 'namespace-uri(//processing-instruction())', '', nsResolver);
|
| /external/llvm/lib/Transforms/InstCombine/ |
| InstCombineShifts.cpp | 21 Instruction *InstCombiner::commonShiftTransforms(BinaryOperator &I) {
32 if (Instruction *R = FoldOpIntoSelect(I, SI))
36 if (Instruction *Res = FoldShiftByConstant(Op0, CUI, I))
73 Instruction *I = dyn_cast<Instruction>(V);
102 // require duplicating the instruction in general, which isn't profitable.
107 case Instruction::And:
108 case Instruction::Or:
109 case Instruction::Xor:
114 case Instruction::Shl:
[all...] |
| /external/llvm/lib/Transforms/Scalar/ |
| LICM.cpp | 20 // we can hoist it or sink it like any other instruction.
21 // 2. Scalar Promotion of Memory - If there is a store instruction inside of
137 /// sink - When an instruction is found to only be used outside of the loop,
141 void sink(Instruction &I);
143 /// hoist - When an instruction is found to only use loop invariant operands
144 /// that is safe to hoist, this instruction is called to do the dirty work.
146 void hoist(Instruction &I);
148 /// isSafeToExecuteUnconditionally - Only sink or hoist an instruction if it
149 /// is not a trapping instruction or if it is a trapping instruction and i
[all...] |
| Sink.cpp | 55 bool SinkInstruction(Instruction *I, SmallPtrSet<Instruction *, 8> &Stores);
56 bool AllUsesDominatedByBlock(Instruction *Inst, BasicBlock *BB) const;
71 bool Sinking::AllUsesDominatedByBlock(Instruction *Inst,
80 Instruction *UseInst = cast<Instruction>(*I);
132 SmallPtrSet<Instruction *, 8> Stores;
134 Instruction *Inst = I; // The instruction to sink.
148 // If we just processed the first instruction in the block, we're done
[all...] |
| /external/llvm/include/llvm-c/ |
| Disassembler.h | 28 * get the symbolic information for an operand of an instruction. Typically
31 * the call back in the DisInfo parameter. The instruction containing operand
32 * is at the PC parameter. For some instruction sets, there can be more than
35 * instruction are specified by the Offset parameter and its byte widith is the
37 * operand per instruction, the Offset parameter will be zero and Size parameter
38 * will be the instruction width. The information is returned in TagBuf and is
94 * offset load instruction to use a symbol name instead of a load address value.
123 * Disassemble a single instruction using the disassembler context specified in
124 * the parameter DC. The bytes of the instruction are specified in the
126 * instruction is at the address specified by the PC parameter. If a vali
[all...] |
| /external/llvm/lib/Transforms/Utils/ |
| DemoteRegToStack.cpp | 11 // virtual register computed by an Instruction and replaces it with a slot in
13 // AllocaInst inserted. After this function is called on an instruction, we are
14 // guaranteed that the only user of the instruction is a store that is
27 /// Instruction and replaces it with a slot in the stack frame, allocated via
32 AllocaInst* llvm::DemoteRegToStack(Instruction &I, bool VolatileLoads,
33 Instruction *AllocaPoint) {
50 // Change all of the users of the instruction to read from the stack slot
53 Instruction *U = cast<Instruction>(I.use_back());
77 // If this is a normal instruction, just insert a load
[all...] |
| AddrModeMatcher.cpp | 17 #include "llvm/Instruction.h"
101 if (isa<Instruction>(ScaleReg) && // not a constant expr.
107 // this instruction.
109 AddrModeInsts.push_back(cast<Instruction>(ScaleReg));
123 static bool MightBeFoldableInst(Instruction *I) {
125 case Instruction::BitCast:
130 case Instruction::PtrToInt:
133 case Instruction::IntToPtr:
136 case Instruction::Add:
138 case Instruction::Mul
[all...] |
| /external/webkit/Source/JavaScriptCore/bytecode/ |
| Instruction.h | 57 // Structure used by op_get_by_id_self_list and op_get_by_id_proto_list instruction to hold data off the main opcode stream.
125 struct Instruction {
126 Instruction(Opcode opcode)
136 Instruction(int operand)
144 Instruction(JSGlobalData& globalData, JSCell* owner, Structure* structure)
149 Instruction(JSGlobalData& globalData, JSCell* owner, StructureChain* structureChain)
154 Instruction(JSGlobalData& globalData, JSCell* owner, JSCell* jsCell)
159 Instruction(PolymorphicAccessStructureList* polymorphicStructures) { u.polymorphicStructures = polymorphicStructures; }
160 Instruction(PropertySlot::GetValueFunc getterFunc) { u.getterFunc = getterFunc; }
173 Instruction(StructureChain*)
[all...] |
| /external/llvm/lib/AsmParser/ |
| LLParser.h | 31 class Instruction;
91 // Instruction metadata resolution. Each instruction can have a list of
96 // instruction metadata kinds, such as dbg, get stored in the IR in an
105 DenseMap<Instruction*, std::vector<MDRef> > ForwardRefInstMetadata;
255 /// SetInstName - After an instruction is parsed and inserted into its
258 Instruction *Inst);
319 bool ParseInstructionMetadata(Instruction *Inst, PerFunctionState *PFS);
335 // Instruction Parsing. Each instruction parsing routine can return with
[all...] |
| /external/llvm/include/llvm/Target/ |
| TargetInstrInfo.h | 1 //===-- llvm/Target/TargetInstrInfo.h - Instruction Info --------*- C++ -*-===//
10 // This file describes the target machine instruction set to the code generator.
42 /// TargetInstrInfo - Interface to description of machine instruction set
55 /// getRegClass - Givem a machine instruction descriptor, returns the register
61 /// isTriviallyReMaterializable - Return true if the instruction is trivially
75 /// specify whether the instruction is actually trivially rematerializable,
77 /// if the instruction has any side effects other than producing a value, or
88 /// target-independent tests to determine if the instruction is really
103 /// isCoalescableExtInstr - Return true if the instruction is a "coalescable"
104 /// extension instruction. That is, it's like a copy where it's legal for th
[all...] |
| /build/core/combo/arch/arm/ |
| armv4t.mk | 5 # it's mostly an obsoleted instruction set architecture (only available
7 # code in assembler source since the bx (branch and exchange) instruction is
|
| /dalvik/dexgen/src/com/android/dexgen/dex/code/ |
| OutputCollector.java | 31 * {@code non-null;} the associated finisher (which holds the instruction
57 * Adds an instruction to the output.
59 * @param insn {@code non-null;} the instruction to add
68 * indicated instruction really is a reversible branch.
71 * {@code 0} is the most recently added instruction,
72 * {@code 1} is the instruction before that, etc.
80 * Adds an instruction to the output suffix.
82 * @param insn {@code non-null;} the instruction to add
|
| /dalvik/dx/src/com/android/dx/dex/code/ |
| OutputCollector.java | 33 * {@code non-null;} the associated finisher (which holds the instruction
60 * Adds an instruction to the output.
62 * @param insn {@code non-null;} the instruction to add
71 * indicated instruction really is a reversible branch.
74 * {@code 0} is the most recently added instruction,
75 * {@code 1} is the instruction before that, etc.
83 * Adds an instruction to the output suffix.
85 * @param insn {@code non-null;} the instruction to add
|
