| /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[]): 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;
[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 | 109 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/ |
| D | arrayDestructuringInSwitch1.ts | 30 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/ |
| 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
|
| /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 | 321 * **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/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/runtime_core/compiler/optimizer/ir/ |
| D | instructions.yaml | 19 Describes signature of the instruction. Properties of the operands are separated by '-' symbol.
230 dyn: dynamic operands, means that operand can repeat zero or more times
234 …Type classes of instruction's operands are equal. Type classes are int, float, ref (see operand_to…
236 … If instrucion's type is float then size of source operands shall be equal to size of destination.
238 …If instrucion's type is integer then size of source operands shall be greater than or equal to siz…
|
| /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|
|