| /external/llvm/include/llvm/CodeGen/ |
| MachineInstr.h | 44 /// MachineInstr - Representation of each machine instruction.
64 FrameSetup = 1 << 0, // Instruction is used as a part of
66 BundledPred = 1 << 1, // Instruction has bundled predecessors.
67 BundledSucc = 1 << 2 // Instruction has bundled successors.
70 const MCInstrDesc *MCID; // Instruction descriptor.
75 unsigned NumOperands; // Number of operands on instruction.
81 // instruction.
208 /// The first instruction has the special opcode "BUNDLE". It's not "inside"
214 /// isBundled - Return true if this instruction part of a bundle. This is true
215 /// if either itself or its following instruction is marked "InsideBundle"
[all...] |
| /art/runtime/verifier/ |
| method_verifier.cc | 361 const Instruction* inst = Instruction::At(code_item_->insns_ + dex_pc);
389 const Instruction* inst = Instruction::At(code_item_->insns_ + dex_pc);
390 const bool is_range = (inst->Opcode() == Instruction::INVOKE_VIRTUAL_RANGE_QUICK);
410 // Allocate and initialize an array to hold instruction data.
416 // Perform static instruction verification.
442 // If we fail again at runtime, mark that this instruction would throw and force this
491 const Instruction* inst = Instruction::At(insns)
[all...] |
| instruction_flags.h | 115 // The instruction has been visited and unless IsChanged() verified.
117 // Register type information flowing into the instruction changed and so the instruction must be
120 // Instruction is contained within a try region.
122 // Instruction is the target of a branch (ie the start of a basic block).
126 // A return instruction.
130 // Size of instruction in code units.
|
| /dalvik/vm/compiler/codegen/x86/libenc/ |
| dec_base.h | 58 * Mnemonic of the instruction.s
76 * Instruction prefixes. Prefix should be placed here according to its group.
80 * Size, in bytes, of the instruction.
84 * Flags of the instruction.
94 * Direct address of the target (on Intel64/IA-32 is 'instruction IP' +
95 * 'instruction length' + offset).
99 * Number of arguments of the instruction.
|
| /external/chromium_org/content/plugin/ |
| plugin_main_linux.cc | 25 char instruction = *reinterpret_cast<char*>(regs[REG_RIP]); local
30 if (signum != SIGILL || instruction != kLAHFInstruction) {
53 // And advance the instruction pointer past the (one-byte) instruction.
59 // 64-bit Flash sometimes uses the LAHF instruction which isn't
61 // (illegal instruction), checking if the signal was caused by this
62 // particular circumstance, emulating the instruction, and resuming.
|
| /external/llvm/include/llvm/Transforms/Utils/ |
| SimplifyLibCalls.h | 22 class Instruction;
38 /// optimizeCall - Take the given call instruction and return a more
39 /// optimal value to replace the instruction with or 0 if a more
41 /// be equal to the instruction being optimized. In this case all
42 /// other instructions that use the given instruction were modified
43 /// and the given instruction is dead.
49 virtual void replaceAllUsesWith(Instruction *I, Value *With) const;
|
| /external/proguard/src/proguard/optimize/evaluation/ |
| LivenessAnalyzer.java | 26 import proguard.classfile.instruction.*;
27 import proguard.classfile.instruction.visitor.InstructionVisitor;
82 * Returns whether the specified variable is alive before the instruction
93 * Sets whether the specified variable is alive before the instruction
113 * Returns whether the specified variable is alive after the instruction
124 * Sets whether the specified variable is alive after the instruction
145 * instruction at the given offset.
156 * instruction at the given offset.
221 // Update the liveness right after the branch instruction.
228 // Update the liveness after the instruction
[all...] |
| /external/proguard/src/proguard/optimize/peephole/ |
| NopRemover.java | 26 import proguard.classfile.instruction.*;
27 import proguard.classfile.instruction.visitor.InstructionVisitor;
71 public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {}
76 // Check if the instruction is a nop instruction.
82 // Visit the instruction, if required.
|
| /external/smali/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/ |
| OffsetInstructionFormatMethodItem.java | 44 OffsetInstruction instruction) {
45 super(codeItem, codeAddress, instruction);
47 label = new LabelMethodItem(codeAddress + instruction.getTargetAddressOffset(), getLabelPrefix());
61 switch (instruction.getFormat()) {
70 if (instruction.opcode == Opcode.FILL_ARRAY_DATA) {
73 if (instruction.opcode == Opcode.PACKED_SWITCH) {
76 assert instruction.opcode == Opcode.SPARSE_SWITCH;
|
| /libcore/luni/src/main/java/org/w3c/dom/ |
| ProcessingInstruction.java | 17 * instruction", used in XML as a way to keep processor-specific information
19 * <p> No lexical check is done on the content of a processing instruction and
22 * instruction per section 2.6 of [<a href='http://www.w3.org/TR/2004/REC-xml-20040204'>XML 1.0</a>]. The
29 * The target of this processing instruction. XML defines this as being
31 * instruction.
36 * The content of this processing instruction. This is from the first non
42 * The content of this processing instruction. This is from the first non
|
| /external/llvm/include/llvm/IR/ |
| Instructions.h | 1 //===-- llvm/Instructions.h - Instruction subclass definitions --*- C++ -*-===//
11 // Instruction class. This is meant to be an easy way to get access to all
12 // instruction subclasses.
58 /// AllocaInst - an instruction to allocate memory on the stack
65 const Twine &Name = "", Instruction *InsertBefore = 0);
69 AllocaInst(Type *Ty, const Twine &Name, Instruction *InsertBefore = 0);
73 const Twine &Name = "", Instruction *InsertBefore = 0);
81 /// to the allocation instruction that is not 1.
94 return cast<PointerType>(Instruction::getType());
98 /// instruction
[all...] |
| /dalvik/vm/compiler/ |
| IntermediateRep.cpp | 31 /* Insert an MIR instruction to the end of a basic block */
46 /* Insert an MIR instruction to the head of a basic block */
61 /* Insert an MIR instruction after the specified MIR */
78 * Append an LIR instruction to the LIR list maintained by a compilation
96 * Insert an LIR instruction before the current instruction, which cannot be the
97 * first instruction.
113 * Insert an LIR instruction after the current instruction, which cannot be the
114 * first instruction
[all...] |
| /external/llvm/docs/HistoricalNotes/ |
| 2002-06-25-MegaPatchInfo.txt | 4 Instruction *I = dyn_cast<Instruction>(V);
6 const Instruction *I = dyn_cast<Instruction>(V);
10 Instruction &I = cast<Instruction>(V);
21 maintained in a doubly linked list of values (ie each Instruction now has
30 example: Instruction&) instead of a pointer to the underlying object. This
52 BasicBlock.h -> Instruction.h
65 pointer. For example, the instruction visitor class uses references instea
[all...] |
| /external/llvm/test/MC/SystemZ/ |
| tokens.s | 4 #CHECK: error: invalid instruction
8 #CHECK: error: invalid instruction
14 #CHECK: error: invalid instruction
26 #CHECK: error: invalid instruction
30 #CHECK: error: invalid instruction
32 #CHECK: error: invalid instruction
36 #CHECK: error: invalid instruction
38 #CHECK: error: invalid instruction
42 #CHECK: error: invalid instruction
44 #CHECK: error: invalid instruction
[all...] |
| /dalvik/vm/analysis/ |
| VfyBasicBlock.h | 36 * the basic block (after the last instruction has executed). Successor
39 * the RegisterLine for the last instruction in the block (which reflects
40 * the state *before* the instruction has executed).
43 u4 firstAddr; /* address of first instruction */
44 u4 lastAddr; /* address of last instruction */
|
| /external/chromium_org/courgette/ |
| assembly_program.h | 21 class Instruction;
23 typedef NoThrowBuffer<Instruction*> InstructionVector;
83 // Following instruction will be assembled at address 'rva'.
86 // Generates a single byte of data or machine instruction.
116 // Accessor for instruction list.
121 // Returns the label if the instruction contains and absolute address,
123 Label* InstructionAbs32Label(const Instruction* instruction) const;
125 // Returns the label if the instruction contains and rel32 offset,
127 Label* InstructionRel32Label(const Instruction* instruction) const
[all...] |
| /external/llvm/include/llvm/Target/ |
| TargetOpcodes.h | 10 // This file defines the target independent instruction opcodes.
19 /// Invariant opcodes: All instruction sets have these as their low opcodes.
21 /// Every instruction defined here must also appear in Target.td and the order
32 /// KILL - This instruction is a noop that is used only to adjust the
37 /// EXTRACT_SUBREG - This instruction takes two operands: a register
43 /// INSERT_SUBREG - This instruction takes three operands: a register that
54 /// SUBREG_TO_REG - This instruction is similar to INSERT_SUBREG except that
56 /// often zero, because it is commonly used to assert that the instruction
60 /// COPY_TO_REGCLASS - This instruction is a placeholder for a plain
62 /// used between instruction selection and MachineInstr creation, befor
[all...] |
| /external/proguard/src/proguard/classfile/attribute/ |
| CodeAttribute.java | 25 import proguard.classfile.instruction.*;
26 import proguard.classfile.instruction.visitor.InstructionVisitor;
106 * Applies the given instruction visitor to all instructions.
115 * Applies the given instruction visitor to the instruction at the specified
120 Instruction instruction = InstructionFactory.create(code, offset); local
121 instruction.accept(clazz, method, this, offset, instructionVisitor);
126 * Applies the given instruction visitor to all instructions in the
135 // Note that the instruction is only volatile
136 Instruction instruction = InstructionFactory.create(code, offset); local
[all...] |
| /external/proguard/src/proguard/classfile/instruction/ |
| SimpleInstruction.java | 21 package proguard.classfile.instruction;
25 import proguard.classfile.instruction.visitor.InstructionVisitor;
28 * This Instruction represents a simple instruction without variable arguments
33 public class SimpleInstruction extends Instruction
64 * Copies the given instruction into this instruction.
65 * @param simpleInstruction the instruction to be copied.
66 * @return this instruction.
106 // Implementations for Instruction
[all...] |
| /art/compiler/dex/portable/ |
| mir_to_gbc.cc | 22 #include <llvm/IR/Instruction.h>
67 // This can happen on instruction rewrite on verification failure
74 ::llvm::Instruction* inst = ::llvm::dyn_cast< ::llvm::Instruction>(placeholder);
128 const Instruction::PackedSwitchPayload* payload =
129 reinterpret_cast<const Instruction::PackedSwitchPayload*>(
152 const Instruction::SparseSwitchPayload* payload =
153 reinterpret_cast<const Instruction::SparseSwitchPayload*>(
691 Instruction::Code opcode = mir->dalvikInsn.opcode;
699 LOG(INFO) << ".. " << Instruction::Name(opcode) << " 0x" << std::hex << op_val
[all...] |
| /external/llvm/lib/AsmParser/ |
| LLParser.h | 34 class Instruction;
94 // Instruction metadata resolution. Each instruction can have a list of
99 // instruction metadata kinds, such as dbg, get stored in the IR in an
108 DenseMap<Instruction*, std::vector<MDRef> > ForwardRefInstMetadata;
287 /// SetInstName - After an instruction is parsed and inserted into its
290 Instruction *Inst);
351 bool ParseInstructionMetadata(Instruction *Inst, PerFunctionState *PFS);
367 // Instruction Parsing. Each instruction parsing routine can return with
[all...] |
| /external/chromium_org/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
83 // Writes one disassembled instruction into 'buffer' (0-terminated).
84 // Returns the length of the disassembled machine instruction in bytes.
85 int InstructionDecode(byte* instruction);
95 void PrintRs(Instruction* instr);
96 void PrintRt(Instruction* instr);
97 void PrintRd(Instruction* instr);
98 void PrintFs(Instruction* instr);
99 void PrintFt(Instruction* instr)
[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...] |
| /external/llvm/lib/Transforms/Scalar/ |
| Sink.cpp | 57 bool SinkInstruction(Instruction *I, SmallPtrSet<Instruction *, 8> &Stores);
58 bool AllUsesDominatedByBlock(Instruction *Inst, BasicBlock *BB) const;
59 bool IsAcceptableTarget(Instruction *Inst, BasicBlock *SuccToSinkTo) const;
74 bool Sinking::AllUsesDominatedByBlock(Instruction *Inst,
83 Instruction *UseInst = cast<Instruction>(*I);
134 SmallPtrSet<Instruction *, 8> Stores;
136 Instruction *Inst = I; // The instruction to sink
[all...] |
| /external/llvm/lib/Transforms/InstCombine/ |
| InstCombineShifts.cpp | 22 Instruction *InstCombiner::commonShiftTransforms(BinaryOperator &I) {
33 if (Instruction *R = FoldOpIntoSelect(I, SI))
37 if (Instruction *Res = FoldShiftByConstant(Op0, CUI, I))
74 Instruction *I = dyn_cast<Instruction>(V);
103 // require duplicating the instruction in general, which isn't profitable.
108 case Instruction::And:
109 case Instruction::Or:
110 case Instruction::Xor:
115 case Instruction::Shl:
[all...] |
