| /arkcompiler/ets_frontend/ts2panda/src/ |
| D | regAllocator.ts | 64 /* check whether the operands is valid for the format,
68 getNumOfInvalidVregs(operands: OperandType[], format: Format): number {
70 for (let j = 0; j < operands.length; ++j) {
71 if (operands[j] instanceof VReg) {
72 if ((<VReg>operands[j]).num >= (1 << format[j][1])) {
80 doRealAdjustment(operands: OperandType[], format: Format, index: number, irNodes: IRNode[]) {
84 for (let j = 0; j < operands.length; ++j) {
85 if (operands[j] instanceof VReg) {
86 let vOrigin = <VReg>operands[j];
89 operands[j] = spill;
[all …]
|
| D | assemblyDumper.ts | 86 … this.output += node.getMnemonic() + " v" + (<VReg>node.operands[0]).num + ", a" + paramIdx + "\n";
101 let operands = node.operands;
104 for (let j = 0; j < operands.length; ++j) {
110 let op = operands[j];
139 if (j < operands.length - 1) {
|
| D | ts2panda.ts | 104 let operands = insn.operands;
106 let operand = operands[i];
129 insn.operands.forEach((operand: OperandType) => {
281 let name = inst.operands[1] as string;
291 let vreg = (inst.operands[0] as VReg).num;
292 let arg = (inst.operands[1] as VReg).num;
303 let vreg = (inst.operands[0] as VReg).num;
|
| /arkcompiler/ets_frontend/ts2panda/templates/ |
| D | builtinsMap.ts.erb | 50 static expand2Builtin(ins: ir.Intrinsic, operands: ir.OperandType[]) {
74 if (!(operands[<%= i-2%>] instanceof ir.Imm)) {
76 % parameters += ", <ir.Imm>operands[" + (i-2).to_s + "]"
79 if (!(operands[<%= i-2%>] instanceof ir.VReg)) {
81 % parameters += ", <ir.VReg>operands[" + (i-2).to_s + "]"
84 if (typeof(operands[<%= i-2%>]) != 'string') {
86 % parameters += ", <string>operands[" + (i-2).to_s + "]"
89 if (typeof(operands[<%= i-2%>]) != 'string') {
91 % parameters += ", <string>operands[" + (i-2).to_s + "]"
98 let imm = <ir.Imm>operands[0];
[all …]
|
| D | irnodes.ts.erb | 46 % dst_operands = insn.operands.select { |op| op.dst? }
114 % _, operands = sig.match(/(\S+) (.+)/).captures
115 % operands = operands.split(', ')
119 % operands = get_operands(insn.sig)
122 % operands.map do |operand|
168 % operands = fmt.operands.map {|op| "[#{get_operand_kind(op, insn)}, #{op.width}]"}
169 % return "[" + operands.join(", ") + "]"
295 readonly operands: OperandType[],
307 this.operands.forEach((element) => {
446 var operands:OperandType[] = [<%=ops_list.join(", ")%>]
[all …]
|
| /arkcompiler/runtime_core/compiler/optimizer/templates/ |
| D | instructions.rb | 135 attr_reader :operands, :inputs accessor in Instruction
140 @operands = signature.map { |sgn| Operand.new(sgn) }
141 if @operands.empty?
144 @inputs = @operands.drop(@operands.first.is_dst? ? 1 : 0)
150 !operands.empty? && operands.first.is_dst?
154 @operands.first
|
| D | IR-instructions.md.erb | 20 null_check_users = IR::instructions.select { |x| x.operands.any? { |o| o.tokens.include? Tokens::Ot…
21 zero_check_users = IR::instructions.select { |x| x.operands.any? { |o| o.tokens.include? Tokens::Ot…
22 bounds_check_users = IR::instructions.select { |x| x.operands.any? { |o| o.tokens.include? Tokens::…
23 negative_check_users = IR::instructions.select { |x| x.operands.any? { |o| o.tokens.include? Tokens…
26 dest = inst.has_dst? ? inst.operands.first.types.join(', ') : ''
|
| D | opcodes.h.erb | 22 % flags << 'pseudo_dst' if !inst.operands.empty? && inst.operands.first.has('pseudo')
23 % flags << 'no_dst' if inst.operands.empty? || !inst.operands.first.is_dst?
|
| /arkcompiler/runtime_core/docs/ |
| D | rationale-for-bytecode.md | 15 also known as operation's _operands_. Operands may be _registers_ (very fast "variables" located
17 operands are _stack operands_ that reside in a special data structure called _stack_. The program
36 hardware world: the terms "operations", "operands", "registers" and "stack" have the same meaning.
43 ## Encoding operands
45 One very important question is how an operation refers to its operands.
47 In _stack-based_ approach, operands are implicitly encoded in the operation, which results in
60 In _register-based approach_, operands are explicitly encoded in the operation, which results in
167 function arguments participate as operands in a fewer number of cases. With that in mind, let's map
172 instruction lacks a wide-range form, we can prepare operands for it with moves that have all
179 overloads are calls (different number of operands) and calls are the most popular instructions in
[all …]
|
| /arkcompiler/runtime_core/assembler/templates/ |
| D | opcode_parsing.h.erb | 30 % operands = insn.operands
49 % required_args = operands.size
52 % operands.each_with_index do |op, j|
116 % if (j >= required_args) && (operands.size > 0)
118 % elsif operands.size > 0
|
| D | operand_types_print.h.erb | 23 % operands = insn.operands
26 % operands_list = operands.map do |op|
|
| D | ins_emit.h.erb | 46 % def operands(insn, regs = "regs")
52 % insn.operands.each do |op|
125 % insn.operands.each do |op|
167 % registers = i.operands.select(&:reg?)
172 emitter.<%= i.emitter_name %>(<%= operands(i, "registers").join(", ") %>);
177 emitter.<%= insn.emitter_name %>(<%= operands(insn).join(", ") %>);
|
| D | ins_to_string.cpp.erb | 34 % operands = insn.operands
|
| D | isa.h.erb | 41 % i.operands.select(&:reg?).map(&:width).max
45 % regs = insn.operands.select(&:reg?)
|
| /arkcompiler/runtime_core/libpandafile/templates/ |
| D | bytecode_instruction-inl_gen.h.erb | 22 % n = i.operands.count(&:id?)
41 % n = i.operands.count(&:reg?)
60 % n = i.operands.count(&:imm?)
95 % n = i.operands.count(&:id?)
98 % id_ops = i.operands.select(&:id?)
129 % n = i.operands.count(&:id?)
132 % id_ops = i.operands.select(&:id?)
161 % n = i.operands.count(&:id?)
164 % id_ops = i.operands.select(&:id?)
190 % n = i.operands.count(&:reg?)
[all …]
|
| D | bytecode_emitter_gen.h.erb | 24 % ops = i.operands
95 % i.operands.each_with_index do |op, index|
130 % offsets = [i.operands.map(&:offset).max, fmt.size * 8]
171 return BytecodeEmitter::BitImmSize::BITSIZE_<%= insn.operands.select(&:imm?).first.width %>;
238 % if group[suit_ind - 1] != nil && w == group[suit_ind - 1].operands.select(&:imm?).first.wid…
|
| /arkcompiler/ets_frontend/ts2panda/tests/utils/ |
| D | base.ts | 100 …let str = "operandsEqual: operands are not one of this types: VReg | Imm | Label | BuiltIns | stri…
113 const operandCount = left.operands.length;
115 const lop = left.operands[i];
116 const rop = right.operands[i];
118 console.log("left.operands:");
119 console.log(left.operands[i]);
120 console.log("right.operands:");
121 console.log(right.operands[i]);
|
| /arkcompiler/ets_runtime/ecmascript/compiler/ |
| D | circuit_ir_specification.md | 334 * **ADD**: returns the sum of its two integer operands.
335 * **SUB**: returns the difference of its two integer operands. It is used to implement the "-" unar…
336 * **MUL**: returns the product of its two integer operands.
338 * **SDIV**: returns the signed quotient of its two integer operands.
339 * **SREM**: returns the remainder from the signed division of its two integer operands.
340 * **UDIV**: returns the unsigned quotient of its two integer operands.
341 * **UREM**: returns the remainder from the unsigned division of its two integer operands.
342 * **AND**: returns the bitwise logical and of its two operands.
343 * **XOR**: returns the bitwise logical exclusive or of its two operands. It is used to implement th…
344 * **OR**: returns the bitwise logical inclusive or of its two operands.
[all …]
|
| /arkcompiler/ets_frontend/es2panda/compiler/templates/ |
| D | formats.h.erb | 53 % operands = fmt.operands.map {|op| "{#{get_operand_kind(op, insn)}, #{op.width}}"}
54 % return operands
|
| D | isa.h.erb | 141 % _, operands = sig.match(/(\S+) (.+)/).captures
142 % operands = operands.split(', ')
146 % operands = get_operands(insn.sig)
151 % operands.map do |operand|
|
| /arkcompiler/runtime_core/isa/ |
| D | isapi.rb | 96 # Signature without operands
152 # Array of explicit operands
153 cached def operands
156 _, operands = sig.match(/(\S+) (.+)/).captures
157 operands = operands.split(', ')
161 operands.map do |operand|
169 operands.map do |operand|
184 # Operands array preceeded with accumulator as if it was a regular operand
188 operands.each_with_object(res) do |op, ops|
|
| D | asserts.rb | 99 assert('Format operands are parseable') { Panda.instructions.each(&:operands) }
109 insns.map { |insn| insn.operands.map(&:name) }.uniq.one?
174 i.operands.select(&:id?).count <= 1
181 registers = i.operands.select(&:reg?)
|
| /arkcompiler/ets_frontend/ts2panda/tests/expression/ |
| D | functionExpression.test.ts | 100 expect(insns.operands[1]).to.equal('UnitTest.a');
128 expect(insns.operands[1]).to.equal('UnitTest.a');
157 expect(insns.operands[1]).to.equal('UnitTest.a');
195 expect(insns.operands[1]).to.equal('UnitTest.p');
300 expect(insns.operands[1]).to.equal('UnitTest.a');
364 expect(insns.operands[1]).to.equal('UnitTest.a');
|
| /arkcompiler/runtime_core/libpandafile/ |
| D | pandafile_isapi.rb | 25 operands.each do |op|
63 insn.operands.each_with_index do |o, i|
|
| /arkcompiler/runtime_core/disassembler/templates/ |
| D | bc_ins_to_pandasm_ins.cpp.erb | 35 % i.operands.each do |operand|
47 % elsif (i.operands.count(&:id?) != 0)
|