Home
last modified time | relevance | path

Searched refs:operands (Results 1 – 25 of 41) sorted by relevance

12

/arkcompiler/ets_frontend/ts2panda/src/
DregAllocator.ts68 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[]): void {
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;
113 let operands = irNodes[index].operands;
[all …]
DassemblyDumper.ts86 … 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) {
Dts2panda.ts109 let operands = insn.operands;
111 let operand = operands[i];
134 insn.operands.forEach((operand: OperandType) => {
179 if ((insn instanceof Defineclasswithbuffer) && (insn.operands[2] === operand)) {
302 let name = inst.operands[1] as string;
312 let vreg = (inst.operands[0] as VReg).num;
313 let arg = (inst.operands[1] as VReg).num;
324 let vreg = (inst.operands[0] as VReg).num;
/arkcompiler/ets_runtime/test/typeinfer/automatedcases/
DarrayDestructuringInSwitch1.ts30 const [operator, ...operands] = expression;
32 AssertType(operands, "union");
41 AssertType(operands.every((child) => evaluate(child)), "boolean");
42 AssertType(operands.every, "union");
48 return operands.every((child) => evaluate(child));
53 AssertType(!evaluate(operands[0]), "boolean");
54 AssertType(evaluate(operands[0]), "boolean");
56 AssertType(operands[0], "Expression");
57 AssertType(operands, "union");
59 return !evaluate(operands[0]);
/arkcompiler/ets_frontend/ts2panda/templates/
DbuiltinsMap.ts.erb50 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 …]
Dirnodes.ts.erb46 % 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/
DIR-instructions.md.erb20 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(', ') : ''
Dopcodes.h.erb22 % 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?
Dinstructions.rb150 !operands.empty? && operands.first.is_dst?
/arkcompiler/runtime_core/assembler/templates/
Dopcode_parsing.h.erb30 % 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
Doperand_types_print.h.erb23 % operands = insn.operands
26 % operands_list = operands.map do |op|
Dins_emit.h.erb46 % 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(", ") %>);
Dins_to_string.cpp.erb34 % operands = insn.operands
Disa.h.erb41 % i.operands.select(&:reg?).map(&:width).max
45 % regs = insn.operands.select(&:reg?)
/arkcompiler/ets_frontend/ts2panda/tests/utils/
Dbase.ts113 const operandCount = left.operands.length;
115 const lop = left.operands[i];
116 const rop = right.operands[i];
119 console.log(left.operands[i]);
121 console.log(right.operands[i]);
/arkcompiler/ets_frontend/ts2panda/tests/expression/
DfunctionExpression.test.ts100 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/templates/
Dbytecode_instruction-inl_gen.h.erb22 % 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 …]
Dbytecode_emitter_gen.h.erb24 % 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/runtime_core/libpandafile/
Dpandafile_isapi.rb25 operands.each do |op|
63 insn.operands.each_with_index do |o, i|
/arkcompiler/ets_runtime/ecmascript/compiler/
Dcircuit_ir_specification.md321 * **ADD**: returns the sum of its two integer operands.
322 * **SUB**: returns the difference of its two integer operands. It is used to implement the "-" unar…
323 * **MUL**: returns the product of its two integer operands.
325 * **SDIV**: returns the signed quotient of its two integer operands.
326 * **SREM**: returns the remainder from the signed division of its two integer operands.
327 * **UDIV**: returns the unsigned quotient of its two integer operands.
328 * **UREM**: returns the remainder from the unsigned division of its two integer operands.
329 * **AND**: returns the bitwise logical and of its two operands.
330 * **XOR**: returns the bitwise logical exclusive or of its two operands. It is used to implement th…
331 * **OR**: returns the bitwise logical inclusive or of its two operands.
[all …]
/arkcompiler/runtime_core/isa/
Disapi.rb153 cached def operands
156 _, operands = sig.match(/(\S+) (.+)/).captures
157 operands = operands.split(', ')
161 operands.map do |operand|
169 operands.map do |operand|
188 operands.each_with_object(res) do |op, ops|
Dasserts.rb109 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/es2panda/compiler/templates/
Dformats.h.erb53 % operands = fmt.operands.map {|op| "{#{get_operand_kind(op, insn)}, #{op.width}}"}
54 % return operands
Disa.h.erb141 % _, operands = sig.match(/(\S+) (.+)/).captures
142 % operands = operands.split(', ')
146 % operands = get_operands(insn.sig)
151 % operands.map do |operand|
/arkcompiler/runtime_core/docs/
Drationale-for-bytecode.md17 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
185 `adda ...` instruction, what are types of its operands?

12