this repo has no description
dekker.one
1/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2
3/*
4 * Main authors:
5 * Jip J. Dekker <jip.dekker@monash.edu>
6 * Guido Tack <guido.tack@monash.edu>
7 */
8
9/* This Source Code Form is subject to the terms of the Mozilla Public
10 * License, v. 2.0. If a copy of the MPL was not distributed with this
11 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
12
13#include <minizinc/interpreter.hh>
14#include <minizinc/interpreter/bytecode.hh>
15
16namespace MiniZinc {
17
18const std::string BytecodeProc::mode_to_string[] = {"ROOT", "ROOT_NEG", "FUN",
19 "FUN_NEG", "IMP", "IMP_NEG"};
20
21std::string BytecodeStream::toString(const std::vector<BytecodeProc>& procs) const {
22 std::ostringstream oss;
23 int pc = 0;
24 while (pc < _bs.size()) {
25 int cur_pc = pc;
26 switch (instr(pc)) {
27 case BytecodeStream::ADDI: {
28 oss << "ADDI R" << reg(pc) << " R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
29 } break;
30 case BytecodeStream::SUBI: {
31 oss << "SUBI R" << reg(pc) << " R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
32 } break;
33 case BytecodeStream::MULI: {
34 oss << "MULI R" << reg(pc) << " R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
35 } break;
36 case BytecodeStream::DIVI: {
37 oss << "DIVI R" << reg(pc) << " R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
38 } break;
39 case BytecodeStream::MODI: {
40 oss << "MODI R" << reg(pc) << " R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
41 } break;
42 case BytecodeStream::INCI: {
43 oss << "INCI R" << reg(pc) << " % " << cur_pc << "\n";
44 } break;
45 case BytecodeStream::DECI: {
46 oss << "DECI R" << reg(pc) << " % " << cur_pc << "\n";
47 } break;
48 case BytecodeStream::IMMI: {
49 oss << "IMMI " << intval(pc).toIntVal() << " R" << reg(pc) << " % " << cur_pc << "\n";
50 } break;
51 case BytecodeStream::CLEAR: {
52 oss << "CLEAR "
53 << " R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
54 } break;
55 case BytecodeStream::LOAD_GLOBAL: {
56 oss << "LOAD_GLOBAL " << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
57 } break;
58 case BytecodeStream::STORE_GLOBAL: {
59 oss << "STORE_GLOBAL R" << reg(pc) << " " << reg(pc) << " % " << cur_pc << "\n";
60 } break;
61 case BytecodeStream::MOV: {
62 oss << "MOV R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
63 } break;
64 case BytecodeStream::JMP: {
65 oss << "JMP " << reg(pc) << " % " << cur_pc << "\n";
66 } break;
67 case BytecodeStream::JMPIF: {
68 oss << "JMPIF R" << reg(pc) << " " << reg(pc) << " % " << cur_pc << "\n";
69 } break;
70 case BytecodeStream::JMPIFNOT: {
71 oss << "JMPIFNOT R" << reg(pc) << " " << reg(pc) << " % " << cur_pc << "\n";
72 } break;
73 case BytecodeStream::EQI: {
74 oss << "EQI R" << reg(pc) << " R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
75 } break;
76 case BytecodeStream::LTI: {
77 oss << "LTI R" << reg(pc) << " R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
78 } break;
79 case BytecodeStream::LEI: {
80 oss << "LEI R" << reg(pc) << " R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
81 } break;
82 case BytecodeStream::AND: {
83 oss << "AND R" << reg(pc) << " R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
84 } break;
85 case BytecodeStream::OR: {
86 oss << "OR R" << reg(pc) << " R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
87 } break;
88 case BytecodeStream::NOT: {
89 oss << "NOT R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
90 } break;
91 case BytecodeStream::XOR: {
92 oss << "XOR R" << reg(pc) << " R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
93 } break;
94 case BytecodeStream::ISPAR: {
95 oss << "ISPAR R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
96 } break;
97 case BytecodeStream::ISEMPTY: {
98 oss << "ISEMPTY R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
99 } break;
100 case BytecodeStream::LENGTH: {
101 oss << "LENGTH R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
102 } break;
103 case BytecodeStream::GET_VEC: {
104 oss << "GET_VEC R" << reg(pc) << " R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc
105 << "\n";
106 } break;
107 case BytecodeStream::GET_ARRAY: {
108 oss << "GET_ARRAY ";
109 long long int n = intval(pc).toInt();
110 oss << n;
111 for (long long int i = 0; i < (n + 3); ++i) {
112 oss << " R" << reg(pc);
113 }
114 oss << " % " << cur_pc << "\n";
115 } break;
116 case BytecodeStream::LB: {
117 oss << "LB R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
118 } break;
119 case BytecodeStream::UB: {
120 oss << "UB R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
121 } break;
122 case BytecodeStream::DOM: {
123 oss << "DOM R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
124 } break;
125 case BytecodeStream::MAKE_SET: {
126 oss << "MAKE_SET R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
127 } break;
128 case BytecodeStream::INTERSECTION: {
129 oss << "INTERSECTION R" << reg(pc) << " R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc
130 << "\n";
131 } break;
132 case BytecodeStream::UNION: {
133 oss << "UNION R" << reg(pc) << " R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc
134 << "\n";
135 } break;
136 case BytecodeStream::DIFF: {
137 oss << "DIFF R" << reg(pc) << " R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
138 } break;
139 case BytecodeStream::INTERSECT_DOMAIN: {
140 oss << "INTERSECT_DOMAIN R" << reg(pc) << " R" << reg(pc) << " R" << reg(pc) << " % "
141 << cur_pc << "\n";
142 } break;
143 case BytecodeStream::RET: {
144 oss << "RET"
145 << " % " << cur_pc << "\n";
146 } break;
147 case BytecodeStream::CALL: {
148 auto m = static_cast<BytecodeProc::Mode>(chr(pc));
149 int p = reg(pc);
150 bool cse = chr(pc);
151 assert(!procs.empty());
152 oss << "CALL " << BytecodeProc::mode_to_string[m] << " " << procs[p].name
153 << (cse ? "" : " no_cse") << " ";
154 oss << procs[p].nargs;
155 for (int i = 0; i < procs[p].nargs; i++) {
156 oss << " R" << reg(pc);
157 }
158 oss << " % " << cur_pc << "\n";
159 } break;
160 case BytecodeStream::BUILTIN: {
161 int p = reg(pc);
162 oss << "BUILTIN " << p << " ";
163 oss << procs[p].nargs;
164 for (int i = 0; i < procs[p].nargs; i++) {
165 oss << " R" << reg(pc);
166 }
167 oss << " % " << cur_pc << "\n";
168 } break;
169 case BytecodeStream::TCALL: {
170 auto m = static_cast<BytecodeProc::Mode>(chr(pc));
171 int p = reg(pc);
172 bool cse = chr(pc);
173
174 if (procs.empty()) {
175 oss << "TCALL " << BytecodeProc::mode_to_string[m] << " " << p << (cse ? "" : " no_cse")
176 << " % " << cur_pc << "\n";
177 } else {
178 oss << "TCALL " << BytecodeProc::mode_to_string[m] << " " << procs[p].name
179 << (cse ? "" : " no_cse") << " % " << cur_pc << "\n";
180 }
181 } break;
182 case BytecodeStream::ITER_ARRAY: {
183 oss << "ITER_ARRAY" << reg(pc) << " " << reg(pc) << " % " << cur_pc << "\n";
184 } break;
185 case BytecodeStream::ITER_VEC: {
186 oss << "ITER_VEC " << reg(pc) << " " << reg(pc) << " % " << cur_pc << "\n";
187 } break;
188 case BytecodeStream::ITER_RANGE: {
189 oss << "ITER_RANGE " << reg(pc) << " " << reg(pc) << " " << reg(pc) << " % " << cur_pc
190 << "\n";
191 } break;
192 case BytecodeStream::ITER_NEXT: {
193 oss << "ITER_NEXT R" << reg(pc) << " % " << cur_pc << "\n";
194 } break;
195 case BytecodeStream::ITER_BREAK: {
196 oss << "ITER_BREAK " << intval(pc).toString() << " % " << cur_pc << "\n";
197 } break;
198 case BytecodeStream::OPEN_AGGREGATION: {
199 oss << "OPEN_AGGREGATION ";
200 int p = chr(pc);
201 switch (p) {
202 case AggregationCtx::VCTX_AND:
203 oss << "AND";
204 break;
205 case AggregationCtx::VCTX_OR:
206 oss << "OR";
207 break;
208 case AggregationCtx::VCTX_VEC:
209 oss << "VEC";
210 break;
211 case AggregationCtx::VCTX_OTHER:
212 oss << "OTHER";
213 break;
214 default:
215 oss << "ERROR";
216 assert(false);
217 break;
218 }
219 oss << " % " << cur_pc << "\n";
220 } break;
221 case BytecodeStream::CLOSE_AGGREGATION: {
222 oss << "CLOSE_AGGREGATION"
223 << " % " << cur_pc << "\n";
224 } break;
225 case BytecodeStream::SIMPLIFY_LIN: {
226 oss << "SIMPLIFY_LIN R" << reg(pc) << " R" << reg(pc) << " " << intval(pc).toIntVal()
227 << " R" << reg(pc) << " R" << reg(pc) << " R" << reg(pc) << " % " << cur_pc << "\n";
228 } break;
229 case BytecodeStream::PUSH: {
230 oss << "PUSH R" << reg(pc) << " % " << cur_pc << "\n";
231 } break;
232 case BytecodeStream::POP: {
233 oss << "POP R" << reg(pc) << " % " << cur_pc << "\n";
234 } break;
235 case BytecodeStream::POST: {
236 oss << "POST R" << reg(pc) << " % " << cur_pc << "\n";
237 } break;
238 case BytecodeStream::TRACE: {
239 oss << "TRACE R" << reg(pc) << " % " << cur_pc << "\n";
240 } break;
241 case BytecodeStream::ABORT: {
242 oss << "ABORT"
243 << " % " << cur_pc << "\n";
244 } break;
245 }
246 }
247 return oss.str();
248}
249
250} // namespace MiniZinc