| /external/v8/src/x87/ |
| assembler-x87.h | 303 friend class Operand;
324 class Operand BASE_EMBEDDED {
327 INLINE(explicit Operand(Register reg));
330 INLINE(explicit Operand(int32_t disp, RelocInfo::Mode rmode));
333 INLINE(explicit Operand(Immediate imm));
336 explicit Operand(Register base, int32_t disp,
340 explicit Operand(Register base,
347 explicit Operand(Register index,
352 static Operand JumpTable(Register index, ScaleFactor scale, Label* table) {
353 return Operand(index, scale, reinterpret_cast<int32_t>(table)
[all...] |
| /device/linaro/bootloader/edk2/EdkCompatibilityPkg/Compatibility/FrameworkHiiOnUefiHiiThunk/ |
| UefiIfrParserExpression.h | 29 Push an Operand onto the Stack
31 @param Operand Operand to push.
40 IN UINT8 Operand
45 Pop an Operand from the Stack
47 @param Operand Operand to pop.
56 OUT UINT8 *Operand
|
| /device/linaro/bootloader/edk2/EdkCompatibilityPkg/Foundation/Library/EfiCommonLib/Ia32/ |
| Log2.S | 30 # IN UINT64 Operand
40 # Operand - value to calculate logarithm
45 # to the logarithm of Operand based on 2
51 cmpl $0, 4(%esp) # (UINT32 *(&Operand))
53 cmpl $0, 8(%esp) # (UINT32 *(&Operand)) + 1
62 btl %ecx, 4(%esp) # (UINT32 *(&Operand))
68 btl %eax, 8(%esp) # (UINT32 *(&Operand)) + 1
|
| Log2.c | 26 IN UINT64 Operand
36 Operand - value to calculate logarithm
41 to the logarithm of Operand based on 2
48 cmp dword ptr Operand[0], 0
50 cmp dword ptr Operand[4], 0
59 bt dword ptr Operand[0], ecx
65 bt dword ptr Operand[4], eax
|
| Power10U64.asm | 18 ; Calculates Operand * 10 ^ Power
39 ; IN UINT64 Operand,
46 ; Raise 10 to the power of Power, and multiply the result with Operand
50 ; Operand - multiplicand
55 ; Operand * 10 ^ Power
61 mov eax, dword ptr [ebp + 8]; dword ptr Operand[0]
62 mov edx, dword ptr [ebp + 0Ch]; dword ptr Operand[4]
69 push [ebp + 0Ch]; dword ptr Operand[4]
70 push [ebp + 8]; dword ptr Operand[0]
74 mov [ebp + 8] , eax; dword ptr Operand[0]
[all...] |
| Power10U64.S | 18 # Calculates Operand * 10 ^ Power
40 # IN UINT64 Operand,
47 # Raise 10 to the power of Power, and multiply the result with Operand
51 # Operand - multiplicand
56 # Operand * 10 ^ Power
62 movl 8(%ebp), %eax # dword ptr Operand[0]
63 movl 0xC(%ebp), %edx # dword ptr Operand[4]
75 movl %eax, 8(%ebp) # dword ptr Operand[0]
76 movl %edx, 0xC(%ebp) # dword ptr Operand[4]
|
| /external/v8/src/regexp/mips/ |
| regexp-macro-assembler-mips.cc | 116 __ li(v0, Operand(FAILURE));
144 current_input_offset(), Operand(by * char_size()));
154 __ Addu(a0, a0, Operand(by));
175 BranchOrBacktrack(on_equal, eq, current_character(), Operand(c));
180 BranchOrBacktrack(on_greater, gt, current_character(), Operand(limit));
186 __ Addu(a0, current_input_offset(), Operand(-char_size()));
187 BranchOrBacktrack(on_at_start, eq, a0, Operand(a1));
195 Operand(-char_size() + cp_offset * char_size()));
196 BranchOrBacktrack(on_not_at_start, ne, a0, Operand(a1));
201 BranchOrBacktrack(on_less, lt, current_character(), Operand(limit))
[all...] |
| /external/v8/src/regexp/mips64/ |
| regexp-macro-assembler-mips64.cc | 152 __ li(v0, Operand(FAILURE));
180 current_input_offset(), Operand(by * char_size()));
190 __ Daddu(a0, a0, Operand(by));
211 BranchOrBacktrack(on_equal, eq, current_character(), Operand(c));
216 BranchOrBacktrack(on_greater, gt, current_character(), Operand(limit));
222 __ Daddu(a0, current_input_offset(), Operand(-char_size()));
223 BranchOrBacktrack(on_at_start, eq, a0, Operand(a1));
231 Operand(-char_size() + cp_offset * char_size()));
232 BranchOrBacktrack(on_not_at_start, ne, a0, Operand(a1));
237 BranchOrBacktrack(on_less, lt, current_character(), Operand(limit))
[all...] |
| /frameworks/compile/mclinker/lib/Script/ |
| RpnEvaluator.cpp | 13 #include "mcld/Script/Operand.h"
34 std::stack<Operand*> operandStack;
46 Operand* opd = operandStack.top();
53 Operand* opd2 = operandStack.top();
55 Operand* opd1 = operandStack.top();
63 Operand* opd3 = operandStack.top();
65 Operand* opd2 = operandStack.top();
67 Operand* opd1 = operandStack.top();
79 case ExprToken::OPERAND: {
80 Operand* opd = llvm::cast<Operand>(*it)
[all...] |
| Operand.cpp | 1 //===- Operand.cpp --------------------------------------------------------===//
9 #include "mcld/Script/Operand.h"
22 // Operand
24 Operand::Operand(Type pType) : ExprToken(ExprToken::OPERAND), m_Type(pType) {
27 Operand::~Operand() {
36 SymOperand::SymOperand() : Operand(Operand::SYMBOL), m_Value(0)
[all...] |
| /frameworks/compile/mclinker/include/mcld/Script/ |
| Operand.h | 1 //===- Operand.h ----------------------------------------------------------===//
25 /** \class Operand
26 * \brief This class defines the interfaces to an operand token.
29 class Operand : public ExprToken {
34 explicit Operand(Type pType);
35 virtual ~Operand();
45 return pToken->kind() == ExprToken::OPERAND;
53 * \brief This class defines the interfaces to a symbol operand.
56 class SymOperand : public Operand {
73 static bool classof(const Operand* pOperand)
[all...] |
| TernaryOp.h | 20 class Operand;
41 void appendOperand(Operand* pOperand) {
49 Operand* m_pOperand[3];
|
| /device/linaro/bootloader/edk2/EdkCompatibilityPkg/Foundation/Library/EdkIIGlueLib/Library/BaseLib/Ia32/ |
| LRotU64.c | 28 IN UINT64 Operand,
34 mov edx, dword ptr [Operand + 4]
35 mov eax, dword ptr [Operand + 0]
|
| RRotU64.c | 20 IN UINT64 Operand,
26 mov eax, dword ptr [Operand + 0]
27 mov edx, dword ptr [Operand + 4]
|
| /device/linaro/bootloader/edk2/MdePkg/Library/BaseLib/Ia32/ |
| LRotU64.c | 22 This function rotates the 64-bit value Operand to the left by Count bits. The
23 low Count bits are fill with the high Count bits of Operand. The rotated
26 @param Operand The 64-bit operand to rotate left.
29 @return Operand <<< Count
35 IN UINT64 Operand,
41 mov edx, dword ptr [Operand + 4]
42 mov eax, dword ptr [Operand + 0]
|
| LShiftU64.c | 22 This function shifts the 64-bit value Operand to the left by Count bits. The
25 @param Operand The 64-bit operand to shift left.
28 @return Operand << Count
34 IN UINT64 Operand,
41 mov edx, dword ptr [Operand + 0]
45 mov edx, dword ptr [Operand + 4]
|
| RRotU64.c | 22 This function rotates the 64-bit value Operand to the right by Count bits.
23 The high Count bits are fill with the low Count bits of Operand. The rotated
26 @param Operand The 64-bit operand to rotate right.
29 @return Operand >>> Count
35 IN UINT64 Operand,
41 mov eax, dword ptr [Operand + 0]
42 mov edx, dword ptr [Operand + 4]
|
| RShiftU64.c | 22 This function shifts the 64-bit value Operand to the right by Count bits. The
25 @param Operand The 64-bit operand to shift right.
28 @return Operand >> Count
34 IN UINT64 Operand,
41 mov eax, dword ptr [Operand + 4]
45 mov eax, dword ptr [Operand + 0]
|
| /external/syslinux/gnu-efi/gnu-efi-3.0/lib/ia64/ |
| math.c | 43 IN UINT64 Operand,
48 return Operand << Count;
53 IN UINT64 Operand,
58 return Operand >> Count;
|
| /device/linaro/bootloader/edk2/EdkCompatibilityPkg/Foundation/Library/Pei/PeiLib/X64/ |
| Math.c | 29 IN UINT64 Operand,
42 Operand - Value to be shifted
52 return Operand << Count;
|
| /external/swiftshader/third_party/subzero/src/ |
| IceTargetLoweringX8632.h | 49 void _add_sp(Operand *Adjustment);
50 void _mov_sp(Operand *NewValue);
52 void _sub_sp(Operand *Adjustment);
63 Inst *emitCallToTarget(Operand *CallTarget, Variable *ReturnReg) override;
64 Variable *moveReturnValueToRegister(Operand *Value, Type ReturnType) override;
72 Operand *createNaClReadTPSrcOperand() {
|
| IceTargetLoweringX8664.h | 52 void _add_sp(Operand *Adjustment);
53 void _mov_sp(Operand *NewValue);
55 void _sub_sp(Operand *Adjustment);
66 Inst *emitCallToTarget(Operand *CallTarget, Variable *ReturnReg) override;
67 Variable *moveReturnValueToRegister(Operand *Value, Type ReturnType) override;
77 Operand *createNaClReadTPSrcOperand() {
|
| /external/v8/src/regexp/arm/ |
| regexp-macro-assembler-arm.cc | 137 current_input_offset(), Operand(by * char_size()));
147 __ add(r0, r0, Operand(by));
157 __ add(pc, r0, Operand(code_pointer()));
167 __ cmp(current_character(), Operand(c));
173 __ cmp(current_character(), Operand(limit));
180 __ add(r0, current_input_offset(), Operand(-char_size()));
190 Operand(-char_size() + cp_offset * char_size()));
197 __ cmp(current_character(), Operand(limit));
206 backtrack_stackpointer(), Operand(kPointerSize), LeaveCC, eq);
230 __ cmn(r1, Operand(current_input_offset()))
[all...] |
| /external/v8/src/regexp/s390/ |
| regexp-macro-assembler-s390.cc | 121 __ LoadImmP(r2, Operand(FAILURE));
145 __ AddP(current_input_offset(), Operand(by * char_size()));
154 __ AddMI(register_location(reg), Operand(by));
157 __ mov(r0, Operand(by));
175 __ CmpLogicalP(current_character(), Operand(c));
180 __ CmpLogicalP(current_character(), Operand(limit));
186 __ AddP(r2, current_input_offset(), Operand(-char_size()));
195 Operand(-char_size() + cp_offset * char_size()));
201 __ CmpLogicalP(current_character(), Operand(limit));
209 __ AddP(backtrack_stackpointer(), Operand(kPointerSize))
[all...] |
| /external/capstone/bindings/java/capstone/ |
| Mips.java | 37 public static class Operand extends Structure {
61 public Operand [] op;
64 op = new Operand[8];
69 op = new Operand[op_count];
82 public Operand [] op;
|
