| /dalvik/vm/mterp/armv6t2/ |
| unop.S | 4 * specifies an instruction that performs "result = op r0".
5 * This could be an ARM instruction or a function call.
19 GOTO_OPCODE(ip) @ jump to next instruction
|
| /dalvik/vm/mterp/c/ |
| OP_MONITOR_EXIT.cpp | 14 * instruction, not the current instruction (see the Dalvik
16 * we're not actually at risk of skipping an instruction
|
| /external/proguard/src/proguard/classfile/util/ |
| InstructionSequenceMatcher.java | 27 import proguard.classfile.instruction.*;
28 import proguard.classfile.instruction.visitor.InstructionVisitor;
31 * This InstructionVisitor checks whether a given pattern instruction sequence
33 * instruction sequence can be wildcards that are matched.
61 private final Instruction[] patternInstructions;
80 * instruction.
81 * @param patternInstructions the pattern instruction sequence.
84 Instruction[] patternInstructions)
95 * Starts matching from the first instruction again next time.
187 Instruction patternInstruction = patternInstructions[patternInstructionIndex]
[all...] |
| /external/proguard/src/proguard/optimize/peephole/ |
| GotoGotoReplacer.java | 26 import proguard.classfile.instruction.*;
27 import proguard.classfile.instruction.visitor.InstructionVisitor;
72 public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {}
77 // Check if the instruction is an unconditional goto instruction.
82 // Check if the goto instruction points to another simple goto
83 // instruction.
91 Instruction targetInstruction =
96 // Simplify the goto instruction
[all...] |
| /external/v8/src/mips/ |
| disasm-mips.cc | 28 // A Disassembler object is used to disassemble a block of code instruction by
29 // instruction. The default implementation of the NameConverter object can be
86 // Writes one disassembled instruction into 'buffer' (0-terminated).
87 // Returns the length of the disassembled machine instruction in bytes.
88 int InstructionDecode(byte_* instruction);
98 void PrintRs(Instruction* instr);
99 void PrintRt(Instruction* instr);
100 void PrintRd(Instruction* instr);
101 void PrintFs(Instruction* instr);
102 void PrintFt(Instruction* instr)
[all...] |
| /dalvik/dx/tests/074-dex-form35c-edge-case/ |
| info.txt | 2 an edge case of instruction format 35c works, where a reference
4 the instruction has to be rewritten to use a different format.
|
| /external/llvm/test/CodeGen/MBlaze/ |
| select.ll | 1 ; Ensure that the select instruction is supported and is lowered to
2 ; some sort of branch instruction.
|
| /external/llvm/test/Transforms/SCCP/ |
| apint-basictest2.ll | 1 ; This is a basic sanity check for constant propagation. The add instruction
2 ; and phi instruction should be eliminated.
|
| /external/webkit/LayoutTests/fast/xpath/py-dom-xpath/ |
| nodetests-expected.txt | 14 PASS doc/child::processing-instruction()
15 PASS doc/child::processing-instruction("one")
|
| /external/llvm/include/llvm/MC/ |
| MCInstrDesc.h | 1 //===-- llvm/Mc/McInstrDesc.h - Instruction Descriptors -*- C++ -*-===//
53 /// instruction, indicating the register class for register operands, etc.
79 /// the predicate operand that controls an isPredicable() instruction.
89 // Machine Instruction Flags and Description
128 /// MCInstrDesc - Describe properties that are true of each instruction in the
131 /// for each target instruction class, and the MachineInstr class points to
140 const char * Name; // Name of the instruction record in td file
165 /// instruction, for example "ADD8ri".
173 /// that the machine instruction may include implicit register def/uses as
187 /// isVariadic - Return true if this instruction can have a variable number o
[all...] |
| /external/llvm/lib/VMCore/ |
| Instruction.cpp | 1 //===-- Instruction.cpp - Implement the Instruction class -----------------===//
10 // This file implements the Instruction class for the VMCore library.
14 #include "llvm/Instruction.h"
23 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
24 Instruction *InsertBefore)
29 // If requested, insert this instruction into a basic block...
32 "Instruction to insert before is not in a basic block!");
37 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps
[all...] |
| /external/llvm/docs/HistoricalNotes/ |
| 2002-05-12-InstListChange.txt | 11 instruction list (returned by getInstList()) that is a ValueHolder of
15 To add or remove an instruction from a basic block, we need to get an
16 iterator to an instruction, which, given just an Instruction*, requires a
17 linear search of the basic block the instruction is contained in... just
18 to insert an instruction before another instruction, or to delete an
19 instruction! This complicates algorithms that should be very simple (like
35 instruction list (which can be found by grep'ing for getInstList()) will
44 for (Instruction *I = BB->front(); I; I = I->getNext()) ..
[all...] |
| /external/proguard/src/proguard/classfile/instruction/ |
| LookUpSwitchInstruction.java | 21 package proguard.classfile.instruction;
25 import proguard.classfile.instruction.visitor.InstructionVisitor;
28 * This Instruction represents a simple instruction without variable arguments
60 * Copies the given instruction into this instruction.
61 * @param lookUpSwitchInstruction the instruction to be copied.
62 * @return this instruction.
75 // Implementations for Instruction.
77 public Instruction shrink(
[all...] |
| TableSwitchInstruction.java | 21 package proguard.classfile.instruction;
25 import proguard.classfile.instruction.visitor.InstructionVisitor;
28 * This Instruction represents a simple instruction without variable arguments
63 * Copies the given instruction into this instruction.
64 * @param tableSwitchInstruction the instruction to be copied.
65 * @return this instruction.
79 // Implementations for Instruction.
81 public Instruction shrink(
[all...] |
| VariableInstruction.java | 21 package proguard.classfile.instruction;
25 import proguard.classfile.instruction.visitor.InstructionVisitor;
28 * This Instruction represents an instruction that refers to a variable on the
33 public class VariableInstruction extends Instruction
78 * Copies the given instruction into this instruction.
79 * @param variableInstruction the instruction to be copied.
80 * @return this instruction.
140 * Returns whether this instruction stores the value of a variable
[all...] |
| /dalvik/dx/src/com/android/dx/rop/ |
| package-info.java | 27 * the dex instruction set.<p>
40 * and potentially local variable information as well for instruction sources
67 * the control flow graph or the instruction list results in replacement
78 * instruction, an instruction whose opcode has a {@link Rop#getBranchingness
80 * instructions may only be the final instruction in any basic block. If
97 * the primary successor) is a property of the final instruction of the basic
100 * {@link ThrowingInsn#getCatches} instruction's catches list, with the
105 * instruction where a catch block exists inside the current method for that
114 * An instruction that may throw an exception may not specify a result. Thi
[all...] |
| /external/llvm/include/llvm/ |
| BasicBlock.h | 17 #include "llvm/Instruction.h"
30 template<> struct ilist_traits<Instruction>
31 : public SymbolTableListTraits<Instruction, BasicBlock> {
36 Instruction *createSentinel() const {
45 return static_cast<Instruction*>(&Sentinel);
47 static void destroySentinel(Instruction*) {}
49 Instruction *provideInitialHead() const { return createSentinel(); }
50 Instruction *ensureHead(Instruction*) const { return createSentinel(); }
51 static void noteHead(Instruction*, Instruction*) {
[all...] |
| /external/llvm/lib/Analysis/ |
| PHITransAddr.cpp | 24 static bool CanPHITrans(Instruction *Inst) {
33 if (Inst->getOpcode() == Instruction::Add &&
55 SmallVectorImpl<Instruction*> &InstInputs) {
56 // If this is a non-instruction value, there is nothing to do.
57 Instruction *I = dyn_cast<Instruction>(Expr);
60 // If it's an instruction, it is either in Tmp or its operands recursively
62 SmallVectorImpl<Instruction*>::iterator Entry =
72 errs() << "Non phi translatable instruction found in PHITransAddr:\n";
79 // Validate the operands of the instruction
[all...] |
| /external/llvm/lib/Target/CppBackend/ |
| CPPBackend.cpp | 20 #include "llvm/Instruction.h"
156 void printInstruction(const Instruction *I, const std::string& bbname);
763 if (CE->getOpcode() == Instruction::GetElementPtr) {
782 case Instruction::Trunc: Out << "Instruction::Trunc"; break;
783 case Instruction::ZExt: Out << "Instruction::ZExt"; break;
784 case Instruction::SExt: Out << "Instruction::SExt"; break;
785 case Instruction::FPTrunc: Out << "Instruction::FPTrunc"; break
[all...] |
| /cts/tools/dx-tests/src/dxc/junit/opcodes/wide/ |
| Test_wide.java | 26 * Wide instruction is tested as part of wide version of particular
27 * instructions so here we just test if wide instruction can't be applied to
33 * @title Wide instruction shall be applied only on defined
47 * @title bytecode modified with wide instruction must not be
|
| /dalvik/dx/tests/093-ssa-invoke-range/ |
| info.txt | 2 for dex's invoke-range instruction.
|
| /dalvik/dx/tests/098-dex-jsr-ret-throw/ |
| info.txt | 2 It contains an example of a subroutine being exited by a "throw" instruction in
|
| /dalvik/vm/compiler/template/armv5te-vfp/ |
| fbinop.S | 3 * specifies an instruction that performs s2 = s0 op s1.
|
| fbinopWide.S | 3 * specifies an instruction that performs s2 = s0 op s1.
|
| /dalvik/vm/mterp/armv5te/ |
| OP_BREAKPOINT.S | 5 * Restart this instruction with the original opcode. By
|
