mirror of
https://github.com/SEPPDROID/Digital-Research-Source-Code.git
synced 2025-10-26 09:54:20 +00:00
879 lines
38 KiB
Plaintext
879 lines
38 KiB
Plaintext
PL/M-86 COMPILER 8086 DISASSEMBLER 5/14/81 PAGE 1
|
||
|
||
|
||
ISIS-II PL/M-86 V2.0 COMPILATION OF MODULE DISEM86
|
||
OBJECT MODULE PLACED IN DIS86.OBJ
|
||
COMPILER INVOKED BY: PLM86 DIS86.PLM DEBUG PAGEWIDTH(100) XREF
|
||
|
||
|
||
|
||
$title('8086 disassembler')
|
||
$date(5/14/81)
|
||
$compact
|
||
$optimize(2)
|
||
|
||
1 disem86: do;
|
||
|
||
2 1 declare
|
||
cr literally '0dh',
|
||
lf literally '0ah',
|
||
true literally '1',
|
||
false literally '0';
|
||
|
||
$include(optab.dat)
|
||
=
|
||
3 1 = declare ops2 (*) byte initial (
|
||
= 'IN', 'JA', 'JB', 'JC', 'JE',
|
||
= 'JG', 'JL', 'JO', 'JP', 'JS',
|
||
= 'JZ', 'OR');
|
||
=
|
||
4 1 = declare ops3 (*) byte initial (
|
||
= 'AAA', 'AAD', 'AAM', 'AAS', 'ADC',
|
||
= 'ADD', 'AND', 'CBW', 'CLC', 'CLD',
|
||
= 'CLI', 'CMC', 'CMP', 'CS:', 'CWD',
|
||
= 'DAA', 'DAS', 'DEC', 'DIV', 'DS:',
|
||
= 'ES:', 'ESC', 'HLT', 'INC', 'INT',
|
||
= 'JAE', 'JBE', 'JGE', 'JLE', 'JMP',
|
||
= 'JNA', 'JNB', 'JNC', 'JNE', 'JNG',
|
||
= 'JNL', 'JNO', 'JNP', 'JNS', 'JNZ',
|
||
= 'JPE', 'JPO', 'LDS', 'LEA', 'LES',
|
||
= 'MOV', 'MUL', 'NEG', 'NOP', 'NOT',
|
||
= 'OUT', 'POP', 'RCL', 'RCR', 'REP',
|
||
= 'RET', 'ROL', 'ROR', 'SAL', 'SAR',
|
||
= 'SBB', 'SHL', 'SHR', 'SS:', 'STC',
|
||
= 'STD', 'STI', 'SUB', 'XOR');
|
||
=
|
||
5 1 = declare ops4 (*) byte initial (
|
||
= 'CALL', 'IDIV', 'IMUL', 'INTO', 'IRET',
|
||
= 'JCXZ', 'JMPF', 'JMPS', 'JNAE', 'JNBE',
|
||
= 'JNGE', 'JNLE', 'LAHF', 'LOCK', 'LOOP',
|
||
= 'POPF', 'PUSH', 'REPE', 'REPZ', 'RETF',
|
||
= 'SAHF', 'TEST', 'WAIT', 'XCHG', 'XLAT');
|
||
=
|
||
6 1 = declare ops5 (*) byte initial (
|
||
= 'CALLF', 'CMPSB', 'CMPSW', 'LODSB', 'LODSW',
|
||
= 'LOOPE', 'LOOPZ', 'MOVSB', 'MOVSW', 'PUSHF',
|
||
= 'REPNE', 'REPNZ', 'SCASB', 'SCASW', 'STOSB',
|
||
= 'STOSW');
|
||
=
|
||
7 1 = declare ops6 (*) byte initial (
|
||
= 'LOOPNE', 'LOOPNZ');
|
||
PL/M-86 COMPILER 8086 DISASSEMBLER 5/14/81 PAGE 2
|
||
|
||
|
||
=
|
||
8 1 = declare nops (5) byte public initial (12, 69, 25, 16, 2);
|
||
=
|
||
9 1 = declare opn$in (*) byte public initial (0, 12, 81, 106, 122, 255);
|
||
|
||
10 1 declare
|
||
tab$ptrs (5) address public initial (.ops2, .ops3, .ops4, .ops5, .ops6);
|
||
|
||
11 1 declare
|
||
left$bracket byte data ('['),
|
||
right$bracket byte data (']');
|
||
|
||
12 1 declare
|
||
alt$table$base address,
|
||
alt$table based alt$table$base (16) byte,
|
||
alt$table$ptrs (8) address external;
|
||
|
||
13 1 declare
|
||
mod$bits byte,
|
||
reg$bits byte,
|
||
rm$bits byte,
|
||
byte1$reg$bits byte,
|
||
d$bit byte,
|
||
s$bit byte,
|
||
v$bit byte,
|
||
w$bit byte,
|
||
z$bit byte;
|
||
|
||
14 1 declare
|
||
mnemonic$index byte, /* index into opcodes */
|
||
instr$type byte,
|
||
table$ptr address,
|
||
table$char based table$ptr byte,
|
||
disem$ptr pointer,
|
||
disem$offset address at (.disem$ptr),
|
||
disem$end address,
|
||
disem$byte based disem$ptr (1) byte,
|
||
disem$word based disem$ptr (1) address,
|
||
b$or$w$flag byte,
|
||
error$flag byte;
|
||
|
||
15 1 declare instr$table (512) byte external;
|
||
|
||
16 1 declare
|
||
ax$reg literally '0',
|
||
cx$reg literally '1',
|
||
dx$reg literally '2',
|
||
bx$reg literally '3',
|
||
sp$reg literally '4',
|
||
bp$reg literally '5',
|
||
si$reg literally '6',
|
||
di$reg literally '7';
|
||
|
||
17 1 declare
|
||
al$reg literally '0',
|
||
cl$reg literally '1',
|
||
dl$reg literally '2',
|
||
PL/M-86 COMPILER 8086 DISASSEMBLER 5/14/81 PAGE 3
|
||
|
||
|
||
bl$reg literally '3',
|
||
ah$reg literally '4',
|
||
ch$reg literally '5',
|
||
dh$reg literally '6',
|
||
bh$reg literally '7';
|
||
|
||
18 1 declare
|
||
es$reg literally '0',
|
||
cs$reg literally '1',
|
||
ss$reg literally '2',
|
||
ds$reg literally '3';
|
||
|
||
19 1 declare
|
||
reg16 (*) byte public initial ('AX', 'CX', 'DX', 'BX', 'SP', 'BP', 'SI', 'DI'),
|
||
reg8 (*) byte public initial ('AL', 'CL', 'DL', 'BL', 'AH', 'CH', 'DH', 'BH'),
|
||
segreg (*) byte public initial ('ES', 'CS', 'SS', 'DS');
|
||
|
||
20 1 conout: procedure (c) external;
|
||
21 2 declare c byte;
|
||
22 2 end conout;
|
||
|
||
23 1 comma: procedure;
|
||
24 2 call conout (',');
|
||
25 2 end comma;
|
||
|
||
26 1 printm: procedure (a) PUBLIC;
|
||
27 2 declare a address;
|
||
28 2 declare b based a byte;
|
||
29 2 do while b <> '$';
|
||
30 3 call conout (b);
|
||
31 3 a = a + 1;
|
||
32 3 end;
|
||
33 2 end printm;
|
||
|
||
34 1 print$nibble: procedure (b);
|
||
35 2 declare b byte;
|
||
36 2 if b > 9 then call conout (b - 10 + 'A');
|
||
38 2 else call conout (b + '0');
|
||
39 2 end print$nibble;
|
||
|
||
40 1 print$byte: procedure (b);
|
||
41 2 declare b byte;
|
||
42 2 call print$nibble (shr (b, 4));
|
||
43 2 call print$nibble (b and 0fh);
|
||
44 2 end print$byte;
|
||
|
||
45 1 print$word: procedure (a) public;
|
||
46 2 declare a address;
|
||
47 2 call print$byte (high (a));
|
||
48 2 call print$byte (low (a));
|
||
49 2 end print$word;
|
||
|
||
50 1 error: procedure;
|
||
51 2 call printm (.('??= $'));
|
||
52 2 call print$byte (disem$byte (0));
|
||
53 2 disem$offset = disem$offset + 1;
|
||
54 2 end error;
|
||
PL/M-86 COMPILER 8086 DISASSEMBLER 5/14/81 PAGE 4
|
||
|
||
|
||
|
||
55 1 set$bits: procedure;
|
||
56 2 byte1$reg$bits = disem$byte (0) and 7;
|
||
57 2 mod$bits = shr (disem$byte (1), 6);
|
||
58 2 reg$bits = shr (disem$byte (1), 3) and 7;
|
||
59 2 rm$bits = disem$byte (1) and 7;
|
||
60 2 w$bit, z$bit = disem$byte (0) and 1;
|
||
61 2 d$bit, s$bit, v$bit = shr (disem$byte (0), 1) and 1;
|
||
62 2 end set$bits;
|
||
|
||
63 1 print$b$or$w: procedure;
|
||
64 2 if w$bit then call printm (.('WORD $'));
|
||
66 2 else call printm (.('BYTE $'));
|
||
67 2 end print$b$or$w;
|
||
|
||
68 1 print$reg: procedure (reg$add, reg);
|
||
69 2 declare reg$add address, reg byte;
|
||
70 2 table$ptr = reg$add + shl (reg, 1);
|
||
71 2 call conout (table$char);
|
||
72 2 table$ptr = table$ptr + 1;
|
||
73 2 call conout (table$char);
|
||
74 2 end print$reg;
|
||
|
||
75 1 print$reg8: procedure (reg);
|
||
76 2 declare reg byte;
|
||
77 2 call print$reg (.reg8, reg);
|
||
78 2 end print$reg8;
|
||
|
||
79 1 print$reg16: procedure (reg);
|
||
80 2 declare reg byte;
|
||
81 2 call print$reg (.reg16, reg);
|
||
82 2 end print$reg16;
|
||
|
||
83 1 print$reg$8$or$16: procedure (reg$num);
|
||
84 2 declare reg$num byte;
|
||
85 2 if w$bit then call print$reg$16 (reg$num);
|
||
87 2 else call print$reg$8 (reg$num);
|
||
88 2 end print$reg$8$or$16;
|
||
|
||
89 1 print$2$reg$16: procedure (r1, r2);
|
||
90 2 declare (r1, r2) byte;
|
||
91 2 call print$reg$16 (r1);
|
||
92 2 call conout ('+');
|
||
93 2 call print$reg$16 (r2);
|
||
94 2 end print$2$reg$16;
|
||
|
||
95 1 print$A$reg: procedure;
|
||
96 2 if w$bit then call print$reg$16 (ax$reg);
|
||
98 2 else call print$reg$8 (al$reg);
|
||
99 2 end print$A$reg;
|
||
|
||
100 1 print$seg$reg: procedure (reg);
|
||
101 2 declare reg byte;
|
||
102 2 call print$reg (.seg$reg, reg);
|
||
103 2 end print$seg$reg;
|
||
|
||
104 1 print$data$8: procedure;
|
||
PL/M-86 COMPILER 8086 DISASSEMBLER 5/14/81 PAGE 5
|
||
|
||
|
||
105 2 call print$byte (disem$byte (0));
|
||
106 2 disem$offset = disem$offset + 1;
|
||
107 2 end print$data$8;
|
||
|
||
108 1 print$data$16: procedure;
|
||
109 2 call print$word (disem$word (0));
|
||
110 2 disem$offset = disem$offset + 2;
|
||
111 2 end print$data$16;
|
||
|
||
112 1 print$data$8$or$16: procedure;
|
||
113 2 if w$bit then call print$data$16;
|
||
115 2 else call print$data$8;
|
||
116 2 end print$data$8$or$16;
|
||
|
||
117 1 print$data$sw: procedure;
|
||
118 2 if rol (disem$byte (0), 1) then call print$word (0ff00h or disem$byte (0));
|
||
120 2 else call print$word (disem$byte (0));
|
||
121 2 disem$offset = disem$offset + 1;
|
||
122 2 end print$data$sw;
|
||
|
||
123 1 print$signed$8: procedure;
|
||
124 2 declare a address;
|
||
125 2 a = disem$byte (0);
|
||
126 2 if low (a) >= 80h then a = a or 0ff00h; /* sign extend to 16 bits */
|
||
128 2 call print$word (disem$offset + a + 1);
|
||
129 2 disem$offset = disem$offset + 1;
|
||
130 2 end print$signed$8;
|
||
|
||
131 1 print$signed$16: procedure;
|
||
132 2 call print$word (disem$offset + disem$word (0) + 2);
|
||
133 2 disem$offset = disem$offset + 2;
|
||
134 2 end print$signed$16;
|
||
|
||
135 1 print$direct$addr: procedure;
|
||
136 2 call conout (left$bracket);
|
||
137 2 call print$word (disem$word (0));
|
||
138 2 call conout (right$bracket);
|
||
139 2 disem$offset = disem$offset + 2;
|
||
140 2 end print$direct$addr;
|
||
|
||
141 1 print$mod$rm: procedure;
|
||
142 2 disem$offset = disem$offset + 1; /* point past mod/reg/rm byte */
|
||
143 2 if mod$bits = 3 then
|
||
144 2 do;
|
||
145 3 call print$reg$8$or$16 (rm$bits);
|
||
146 3 return;
|
||
147 3 end;
|
||
148 2 if b$or$w$flag then call print$b$or$w;
|
||
150 2 if rm$bits = 6 and mod$bits = 0 then
|
||
151 2 do;
|
||
152 3 call print$direct$addr;
|
||
153 3 return;
|
||
154 3 end;
|
||
155 2 if mod$bits = 1 then
|
||
156 2 do;
|
||
157 3 if (rm$bits <> 6) or (disem$byte (0) <> 0)
|
||
then call print$byte (disem$byte (0));
|
||
PL/M-86 COMPILER 8086 DISASSEMBLER 5/14/81 PAGE 6
|
||
|
||
|
||
159 3 disem$offset = disem$offset + 1;
|
||
160 3 end;
|
||
161 2 else if mod$bits = 2 then
|
||
162 2 do;
|
||
163 3 call print$word (disem$word (0));
|
||
164 3 disem$offset = disem$offset + 2;
|
||
165 3 end;
|
||
call conout (left$bracket);
|
||
167 2 do case rm$bits;
|
||
168 3 call print$2$reg$16 (3, 6);
|
||
169 3 call print$2$reg$16 (3, 7);
|
||
170 3 call print$2$reg$16 (5, 6);
|
||
171 3 call print$2$reg$16 (5, 7);
|
||
172 3 call print$reg$16 (6);
|
||
173 3 call print$reg$16 (7);
|
||
174 3 call print$reg$16 (5);
|
||
175 3 call print$reg$16 (3);
|
||
176 3 end;
|
||
177 2 call conout (right$bracket);
|
||
178 2 end print$mod$rm;
|
||
|
||
179 1 print$mod$reg$rm: procedure;
|
||
180 2 if d$bit then
|
||
181 2 do;
|
||
182 3 call print$reg$8$or$16 (reg$bits);
|
||
183 3 call conout (',');
|
||
184 3 call print$mod$rm;
|
||
185 3 end;
|
||
else
|
||
186 2 do;
|
||
187 3 call print$mod$rm;
|
||
188 3 call conout (',');
|
||
189 3 call print$reg$8$or$16 (reg$bits);
|
||
190 3 end;
|
||
191 2 end print$mod$reg$rm;
|
||
|
||
192 1 print$mnemonic: procedure;
|
||
193 2 declare (len, i) byte;
|
||
194 2 len = 2;
|
||
195 2 do while mnemonic$index >= opn$in (len - 1);
|
||
196 3 len = len + 1;
|
||
197 3 end;
|
||
198 2 table$ptr = tab$ptrs (len - 2) + (mnemonic$index - opn$in (len - 2))
|
||
* len;
|
||
199 2 do i = 1 to 7;
|
||
200 3 if i <= len then
|
||
201 3 do;
|
||
202 4 call conout (table$char);
|
||
203 4 table$ptr = table$ptr + 1;
|
||
204 4 end;
|
||
205 3 else call conout (' ');
|
||
206 3 end;
|
||
207 2 disem$offset = disem$offset + 1;
|
||
208 2 end print$mnemonic;
|
||
|
||
209 1 type1: procedure;
|
||
210 2 call print$mnemonic;
|
||
PL/M-86 COMPILER 8086 DISASSEMBLER 5/14/81 PAGE 7
|
||
|
||
|
||
211 2 end type1;
|
||
|
||
212 1 type2: procedure;
|
||
213 2 if disem$byte (1) = 0ah then
|
||
214 2 do;
|
||
215 3 call print$mnemonic;
|
||
216 3 disem$offset = disem$offset + 1;
|
||
217 3 end;
|
||
218 2 else error$flag = true;
|
||
219 2 end type2;
|
||
|
||
220 1 type3: procedure;
|
||
221 2 call print$mnemonic;
|
||
222 2 call print$reg$16 (byte1$reg$bits);
|
||
223 2 end type3;
|
||
|
||
224 1 type4: procedure;
|
||
225 2 declare temp byte;
|
||
226 2 temp = shr (disem$byte (0), 3) and 3;
|
||
227 2 call print$mnemonic;
|
||
228 2 call print$segreg (temp);
|
||
229 2 end type4;
|
||
|
||
230 1 type5: procedure;
|
||
231 2 call print$mnemonic;
|
||
232 2 call print$signed$8;
|
||
233 2 end type5;
|
||
|
||
234 1 type6: procedure;
|
||
235 2 call print$mnemonic;
|
||
236 2 call print$signed$16;
|
||
237 2 end type6;
|
||
|
||
238 1 type8: procedure; /* 7, 9 */
|
||
239 2 call print$mnemonic;
|
||
240 2 call print$mod$rm;
|
||
241 2 end type8;
|
||
|
||
242 1 type10: procedure;
|
||
243 2 call print$mnemonic;
|
||
244 2 call print$data$8;
|
||
245 2 end type10;
|
||
|
||
246 1 type11: procedure;
|
||
247 2 call print$mnemonic;
|
||
248 2 call print$data$16;
|
||
249 2 end type11;
|
||
|
||
250 1 type12: procedure;
|
||
251 2 call print$mnemonic;
|
||
252 2 call conout ('3');
|
||
253 2 end type12;
|
||
|
||
254 1 type13: procedure;
|
||
255 2 declare temp address;
|
||
256 2 call print$mnemonic;
|
||
257 2 temp = disem$word (0);
|
||
PL/M-86 COMPILER 8086 DISASSEMBLER 5/14/81 PAGE 8
|
||
|
||
|
||
258 2 disem$offset = disem$offset + 2;
|
||
259 2 call print$data$16;
|
||
260 2 call conout (':');
|
||
261 2 call print$word (temp);
|
||
262 2 end type13;
|
||
|
||
263 1 type14: procedure; /* 15, 16, 17 */
|
||
264 2 call print$mnemonic;
|
||
265 2 call print$mod$reg$rm;
|
||
266 2 end type14;
|
||
|
||
267 1 type18: procedure; /* 19, 20, 21 */
|
||
268 2 call print$mnemonic;
|
||
269 2 if d$bit then
|
||
270 2 do;
|
||
271 3 call print$direct$addr;
|
||
272 3 call comma;
|
||
273 3 call print$A$reg;
|
||
274 3 end;
|
||
else
|
||
275 2 do;
|
||
276 3 call print$A$reg;
|
||
277 3 call comma;
|
||
278 3 call print$direct$addr;
|
||
279 3 end;
|
||
280 2 end type18;
|
||
|
||
281 1 type22: procedure;
|
||
282 2 call print$mnemonic;
|
||
283 2 if d$bit then
|
||
284 2 do;
|
||
285 3 call print$data$8;
|
||
286 3 call comma;
|
||
287 3 call print$A$reg;
|
||
288 3 end;
|
||
else
|
||
289 2 do;
|
||
290 3 call print$A$reg;
|
||
291 3 call comma;
|
||
292 3 call print$data$8;
|
||
293 3 end;
|
||
294 2 end type22;
|
||
|
||
295 1 type23: procedure; /* 24 */
|
||
296 2 call print$mnemonic;
|
||
297 2 call print$A$reg;
|
||
298 2 call comma;
|
||
299 2 call print$data$8$or$16;
|
||
300 2 end type23;
|
||
|
||
301 1 type25: procedure; /* 26 */
|
||
302 2 call print$mnemonic;
|
||
303 2 if d$bit then
|
||
304 2 do;
|
||
305 3 call print$reg$16 (dx$reg);
|
||
306 3 call comma;
|
||
307 3 call print$A$reg;
|
||
PL/M-86 COMPILER 8086 DISASSEMBLER 5/14/81 PAGE 9
|
||
|
||
|
||
308 3 end;
|
||
else
|
||
309 2 do;
|
||
310 3 call print$A$reg;
|
||
311 3 call comma;
|
||
312 3 call print$reg$16 (dx$reg);
|
||
313 3 end;
|
||
314 2 end type25;
|
||
|
||
315 1 type27: procedure; /* 28, 29, 30 */
|
||
316 2 call print$mnemonic;
|
||
317 2 b$or$w$flag = true;
|
||
318 2 call print$mod$rm;
|
||
319 2 call comma;
|
||
320 2 if v$bit then call print$reg$8 (cl$reg);
|
||
322 2 else call conout ('1');
|
||
323 2 end type27;
|
||
|
||
324 1 type31: procedure; /* 32 */
|
||
325 2 call setbits;
|
||
326 2 reg$bits = byte1$reg$bits;
|
||
327 2 w$bit = shr (disem$byte (0), 3) and 1;
|
||
328 2 call print$mnemonic;
|
||
329 2 call print$reg$8$or$16 (reg$bits);
|
||
330 2 call comma;
|
||
331 2 call print$data$8$or$16;
|
||
332 2 end type31;
|
||
|
||
333 1 type33: procedure;
|
||
334 2 call print$mnemonic;
|
||
335 2 call print$reg$16 (ax$reg);
|
||
336 2 call comma;
|
||
337 2 call print$reg$16 (byte1$reg$bits);
|
||
338 2 end type33;
|
||
|
||
339 1 type34: procedure; /* 35 */
|
||
340 2 call print$mnemonic;
|
||
341 2 b$or$w$flag = true;
|
||
342 2 call print$mod$rm;
|
||
343 2 call comma;
|
||
344 2 call print$data$8$or$16;
|
||
345 2 end type34;
|
||
|
||
346 1 type36: procedure; /* 37 */
|
||
347 2 w$bit = true; /* force 16 bit reg, mem */
|
||
348 2 if reg$bits > 3 then
|
||
349 2 do;
|
||
350 3 error$flag = true;
|
||
351 3 return;
|
||
352 3 end;
|
||
353 2 call print$mnemonic;
|
||
354 2 if d$bit then
|
||
355 2 do;
|
||
356 3 call print$seg$reg (reg$bits);
|
||
357 3 call comma;
|
||
358 3 call print$mod$rm;
|
||
359 3 end;
|
||
PL/M-86 COMPILER 8086 DISASSEMBLER 5/14/81 PAGE 10
|
||
|
||
|
||
else
|
||
360 2 do;
|
||
361 3 call print$mod$rm;
|
||
362 3 call comma;
|
||
363 3 call print$seg$reg (reg$bits);
|
||
364 3 end;
|
||
365 2 end type36;
|
||
|
||
366 1 type38: procedure;
|
||
367 2 call print$mnemonic;
|
||
368 2 call print$mod$rm;
|
||
369 2 call comma;
|
||
370 2 call print$data$8;
|
||
371 2 end type38;
|
||
|
||
372 1 type39: procedure;
|
||
373 2 if mod$bits = 3 then
|
||
374 2 do;
|
||
375 3 error$flag = true;
|
||
376 3 return;
|
||
377 3 end;
|
||
378 2 call print$mnemonic;
|
||
379 2 call print$reg$16 (reg$bits);
|
||
380 2 call comma;
|
||
381 2 call print$mod$rm;
|
||
382 2 end type39;
|
||
|
||
383 1 type40: procedure; /* 41 */
|
||
384 2 if mod$bits = 3 then
|
||
385 2 do;
|
||
386 3 error$flag = true;
|
||
387 3 return;
|
||
388 3 end;
|
||
389 2 call print$mnemonic;
|
||
390 2 b$or$w$flag = true;
|
||
391 2 call print$mod$rm;
|
||
392 2 call comma;
|
||
393 2 call print$data$8$or$16;
|
||
394 2 end type40;
|
||
|
||
395 1 type42: procedure;
|
||
396 2 call print$mnemonic;
|
||
397 2 call print$byte (shl (byte1$reg$bits, 3) or reg$bits);
|
||
398 2 call comma;
|
||
399 2 call print$mod$rm;
|
||
400 2 end type42;
|
||
|
||
401 1 type44: procedure;
|
||
402 2 call print$mnemonic;
|
||
403 2 b$or$w$flag = true;
|
||
404 2 call print$modrm;
|
||
405 2 call comma;
|
||
406 2 if s$bit = 1 and w$bit = 1 then call print$data$sw;
|
||
408 2 else call print$data$8$or$16;
|
||
409 2 end type44;
|
||
|
||
410 1 type45: procedure;
|
||
PL/M-86 COMPILER 8086 DISASSEMBLER 5/14/81 PAGE 11
|
||
|
||
|
||
411 2 b$or$w$flag = true;
|
||
412 2 call type8;
|
||
413 2 end type45;
|
||
|
||
414 1 dis: procedure;
|
||
415 2 error$flag, b$or$w$flag = false;
|
||
416 2 call set$bits;
|
||
417 2 if instr$type = 26 then
|
||
418 2 do;
|
||
419 3 alt$table$base = alt$table$ptrs (mnemonic$index);
|
||
420 3 mnemonic$index = alt$table (reg$bits * 2);
|
||
421 3 instr$type = alt$table (reg$bits * 2 + 1);
|
||
422 3 end;
|
||
423 2 if instr$type > 28 then error$flag = true;
|
||
else
|
||
425 2 do case instr$type;
|
||
426 3 error$flag = true;
|
||
427 3 call type1;
|
||
428 3 call type2;
|
||
429 3 call type3;
|
||
430 3 call type4;
|
||
431 3 call type5;
|
||
432 3 call type6;
|
||
433 3 call type8;
|
||
434 3 call type10;
|
||
435 3 call type11;
|
||
436 3 call type12;
|
||
437 3 call type13;
|
||
438 3 call type14;
|
||
439 3 call type18;
|
||
440 3 call type22;
|
||
441 3 call type23;
|
||
442 3 call type25;
|
||
443 3 call type27;
|
||
444 3 call type31;
|
||
445 3 call type33;
|
||
446 3 call type34;
|
||
447 3 call type36;
|
||
448 3 call type38;
|
||
449 3 call type39;
|
||
450 3 call type40;
|
||
451 3 call type42;
|
||
452 3 ;
|
||
453 3 call type44;
|
||
454 3 call type45;
|
||
455 3 end;
|
||
456 2 if error$flag then call error;
|
||
458 2 end dis;
|
||
|
||
459 1 disem: procedure (disloc) address public;
|
||
460 2 declare disloc pointer;
|
||
461 2 declare nprefix byte;
|
||
462 2 disem$ptr = disloc;
|
||
463 2 nprefix = 0;
|
||
464 2 do while true;
|
||
465 3 mnemonic$index = instr$table (disem$byte (0) * 2);
|
||
466 3 instr$type = instr$table (disem$byte (0) * 2 + 1);
|
||
PL/M-86 COMPILER 8086 DISASSEMBLER 5/14/81 PAGE 12
|
||
|
||
|
||
467 3 if instr$type = 0ffh and nprefix < 3 then
|
||
468 3 do;
|
||
469 4 call print$mnemonic;
|
||
470 4 nprefix = nprefix + 1;
|
||
471 4 end;
|
||
else
|
||
472 3 do;
|
||
473 4 if instr$type = 0ffh then instr$type = 1;
|
||
475 4 call dis;
|
||
476 4 return disem$offset;
|
||
477 4 end;
|
||
478 3 end;
|
||
479 2 end disem;
|
||
|
||
480 1 end disem86;
|
||
PL/M-86 COMPILER 8086 DISASSEMBLER 5/14/81 PAGE 13
|
||
|
||
|
||
CROSS-REFERENCE LISTING
|
||
-----------------------
|
||
|
||
|
||
DEFN ADDR SIZE NAME, ATTRIBUTES, AND REFERENCES
|
||
----- ------ ----- --------------------------------
|
||
|
||
|
||
124 0014H 2 A. . . . . . . . . WORD 125 126 127 128
|
||
45 0004H 2 A. . . . . . . . . WORD PARAMETER AUTOMATIC 46 47 48
|
||
26 0004H 2 A. . . . . . . . . WORD PARAMETER AUTOMATIC 27 28 29 30
|
||
31
|
||
17 AHREG. . . . . . . LITERALLY
|
||
17 ALREG. . . . . . . LITERALLY 98
|
||
12 0000H 16 ALTTABLE . . . . . BYTE BASED(ALTTABLEBASE) ARRAY(16) 420 421
|
||
12 000AH 2 ALTTABLEBASE . . . WORD 12 419 420 421
|
||
12 0000H 16 ALTTABLEPTRS . . . WORD ARRAY(8) EXTERNAL(0) 419
|
||
16 AXREG. . . . . . . LITERALLY 97 335
|
||
40 0004H 1 B. . . . . . . . . BYTE PARAMETER AUTOMATIC 41 42 43
|
||
34 0004H 1 B. . . . . . . . . BYTE PARAMETER AUTOMATIC 35 36 37 38
|
||
28 0000H 1 B. . . . . . . . . BYTE BASED(A) 29 30
|
||
17 BHREG. . . . . . . LITERALLY
|
||
17 BLREG. . . . . . . LITERALLY
|
||
14 01D5H 1 BORWFLAG . . . . . BYTE 148 317 341 390 403 411 415
|
||
16 BPREG. . . . . . . LITERALLY
|
||
16 BXREG. . . . . . . LITERALLY
|
||
13 01CDH 1 BYTE1REGBITS . . . BYTE 56 222 326 337 397
|
||
20 0000H 1 C. . . . . . . . . BYTE PARAMETER 21
|
||
17 CHREG. . . . . . . LITERALLY
|
||
17 CLREG. . . . . . . LITERALLY 321
|
||
23 0002H 11 COMMA. . . . . . . PROCEDURE STACK=0006H 272 277 286 291
|
||
298 306 311 319 330 336 343 357 362 369
|
||
380 392 398 405
|
||
20 0000H CONOUT . . . . . . PROCEDURE EXTERNAL(2) STACK=0000H 24 30
|
||
37 38 71 73 92 136 138 166 177 183
|
||
188 202 205 252 260 322
|
||
2 CR . . . . . . . . LITERALLY
|
||
18 CSREG. . . . . . . LITERALLY
|
||
16 CXREG. . . . . . . LITERALLY
|
||
13 01CEH 1 DBIT . . . . . . . BYTE 61 180 269 283 303 354
|
||
17 DHREG. . . . . . . LITERALLY
|
||
16 DIREG. . . . . . . LITERALLY
|
||
414 0694H 295 DIS. . . . . . . . PROCEDURE STACK=0028H 475
|
||
459 07BBH 90 DISEM. . . . . . . PROCEDURE WORD PUBLIC STACK=0030H
|
||
1 0002H DISEM86. . . . . . PROCEDURE STACK=0000H
|
||
14 0000H 1 DISEMBYTE. . . . . BYTE BASED(DISEMPTR) ARRAY(1) 52 56 57
|
||
58 59 60 61 105 118 119 120 125 157
|
||
158 213 226 327 465 466
|
||
14 0012H 2 DISEMEND . . . . . WORD
|
||
14 000EH 2 DISEMOFFSET. . . . WORD AT 53 106 110 121 128 129 132
|
||
133 139 142 159 164 207 216 258 476
|
||
14 000EH 4 DISEMPTR . . . . . POINTER 14 52 56 57 58 59 60
|
||
61 105 109 118 119 120 125 132 137 157
|
||
158 163 213 226 257 327 462 465 466
|
||
14 0000H 2 DISEMWORD. . . . . WORD BASED(DISEMPTR) ARRAY(1) 109 132 137
|
||
163 257
|
||
459 0004H 4 DISLOC . . . . . . POINTER PARAMETER AUTOMATIC 460 462
|
||
PL/M-86 COMPILER 8086 DISASSEMBLER 5/14/81 PAGE 14
|
||
|
||
|
||
17 DLREG. . . . . . . LITERALLY
|
||
18 DSREG. . . . . . . LITERALLY
|
||
16 DXREG. . . . . . . LITERALLY 305 312
|
||
50 0077H 26 ERROR. . . . . . . PROCEDURE STACK=0012H 457
|
||
14 01D6H 1 ERRORFLAG. . . . . BYTE 218 350 375 386 415 424 426 456
|
||
18 ESREG. . . . . . . LITERALLY
|
||
2 FALSE. . . . . . . LITERALLY 415
|
||
HIGH . . . . . . . BUILTIN 47
|
||
193 0200H 1 I. . . . . . . . . BYTE 199 200
|
||
15 0000H 512 INSTRTABLE . . . . BYTE ARRAY(512) EXTERNAL(1) 465 466
|
||
14 01D4H 1 INSTRTYPE. . . . . BYTE 417 421 423 425 466 467 473 474
|
||
11 0000H 1 LEFTBRACKET. . . . BYTE DATA 136 166
|
||
193 01FFH 1 LEN. . . . . . . . BYTE 194 195 196 198 200
|
||
2 LF . . . . . . . . LITERALLY
|
||
LOW. . . . . . . . BUILTIN 48 126
|
||
14 01D3H 1 MNEMONICINDEX. . . BYTE 195 198 419 420 465
|
||
13 01CAH 1 MODBITS. . . . . . BYTE 57 143 150 155 161 373 384
|
||
8 01BFH 5 NOPS . . . . . . . BYTE ARRAY(5) PUBLIC INITIAL
|
||
461 0202H 1 NPREFIX. . . . . . BYTE 463 467 470
|
||
9 01C4H 6 OPNIN. . . . . . . BYTE ARRAY(6) PUBLIC INITIAL 195 198
|
||
3 0018H 24 OPS2 . . . . . . . BYTE ARRAY(24) INITIAL 10
|
||
4 0030H 207 OPS3 . . . . . . . BYTE ARRAY(207) INITIAL 10
|
||
5 00FFH 100 OPS4 . . . . . . . BYTE ARRAY(100) INITIAL 10
|
||
6 0163H 80 OPS5 . . . . . . . BYTE ARRAY(80) INITIAL 10
|
||
7 01B3H 12 OPS6 . . . . . . . BYTE ARRAY(12) INITIAL 10
|
||
89 0159H 25 PRINT2REG16. . . . PROCEDURE STACK=0018H 168 169 170 171
|
||
95 0172H 26 PRINTAREG. . . . . PROCEDURE STACK=0014H 273 276 287 290
|
||
297 307 310
|
||
63 00DAH 24 PRINTBORW. . . . . PROCEDURE STACK=000CH 149
|
||
40 0045H 27 PRINTBYTE. . . . . PROCEDURE STACK=000EH 47 48 52 105
|
||
158 397
|
||
108 01B0H 20 PRINTDATA16. . . . PROCEDURE STACK=0018H 114 248 259
|
||
104 019DH 19 PRINTDATA8 . . . . PROCEDURE STACK=0012H 115 244 285 292
|
||
370
|
||
112 01C4H 20 PRINTDATA8OR16 . . PROCEDURE STACK=001CH 299 331 344 393
|
||
408
|
||
117 01D8H 45 PRINTDATASW. . . . PROCEDURE STACK=0018H 407
|
||
135 024BH 34 PRINTDIRECTADDR. . PROCEDURE STACK=0018H 152 271 278
|
||
26 000DH 25 PRINTM . . . . . . PROCEDURE PUBLIC STACK=0008H 51 65 66
|
||
192 0368H 116 PRINTMNEMONIC. . . PROCEDURE STACK=0006H 210 215 221 227
|
||
231 235 239 243 247 251 256 264 268 282
|
||
296 302 316 328 334 340 353 367 378 389
|
||
396 402 469
|
||
179 033AH 46 PRINTMODREGRM. . . PROCEDURE STACK=0020H 265
|
||
141 026DH 205 PRINTMODRM . . . . PROCEDURE STACK=001CH 184 187 240 318
|
||
342 358 361 368 381 391 399 404
|
||
34 0026H 31 PRINTNIBBLE. . . . PROCEDURE STACK=0008H 42 43
|
||
68 00F2H 41 PRINTREG . . . . . PROCEDURE STACK=000AH 77 81 102
|
||
79 012CH 17 PRINTREG16 . . . . PROCEDURE STACK=0010H 86 91 93 97
|
||
172 173 174 175 222 305 312 335 337 379
|
||
75 011BH 17 PRINTREG8. . . . . PROCEDURE STACK=0010H 87 98 321
|
||
83 013DH 28 PRINTREG8OR16. . . PROCEDURE STACK=0016H 145 182 189 329
|
||
100 018CH 17 PRINTSEGREG. . . . PROCEDURE STACK=0010H 228 356 363
|
||
131 0230H 27 PRINTSIGNED16. . . PROCEDURE STACK=0018H 236
|
||
123 0205H 43 PRINTSIGNED8 . . . PROCEDURE STACK=0018H 232
|
||
45 0060H 23 PRINTWORD. . . . . PROCEDURE PUBLIC STACK=0014H 109 119 120
|
||
128 132 137 163 261
|
||
PL/M-86 COMPILER 8086 DISASSEMBLER 5/14/81 PAGE 15
|
||
|
||
|
||
89 0006H 1 R1 . . . . . . . . BYTE PARAMETER AUTOMATIC 90 91
|
||
89 0004H 1 R2 . . . . . . . . BYTE PARAMETER AUTOMATIC 90 93
|
||
100 0004H 1 REG. . . . . . . . BYTE PARAMETER AUTOMATIC 101 102
|
||
79 0004H 1 REG. . . . . . . . BYTE PARAMETER AUTOMATIC 80 81
|
||
75 0004H 1 REG. . . . . . . . BYTE PARAMETER AUTOMATIC 76 77
|
||
68 0004H 1 REG. . . . . . . . BYTE PARAMETER AUTOMATIC 69 70
|
||
19 01D7H 16 REG16. . . . . . . BYTE ARRAY(16) PUBLIC INITIAL 81
|
||
19 01E7H 16 REG8 . . . . . . . BYTE ARRAY(16) PUBLIC INITIAL 77
|
||
68 0006H 2 REGADD . . . . . . WORD PARAMETER AUTOMATIC 69 70
|
||
13 01CBH 1 REGBITS. . . . . . BYTE 58 182 189 326 329 348 356 363
|
||
379 397 420 421
|
||
83 0004H 1 REGNUM . . . . . . BYTE PARAMETER AUTOMATIC 84 86 87
|
||
11 0001H 1 RIGHTBRACKET . . . BYTE DATA 138 177
|
||
13 01CCH 1 RMBITS . . . . . . BYTE 59 145 150 157 167
|
||
ROL. . . . . . . . BUILTIN 118
|
||
13 01CFH 1 SBIT . . . . . . . BYTE 61 406
|
||
19 01F7H 8 SEGREG . . . . . . BYTE ARRAY(8) PUBLIC INITIAL 102
|
||
55 0091H 73 SETBITS. . . . . . PROCEDURE STACK=0006H 325 416
|
||
SHL. . . . . . . . BUILTIN 70 397
|
||
SHR. . . . . . . . BUILTIN 42 57 58 61 226 327
|
||
16 SIREG. . . . . . . LITERALLY
|
||
16 SPREG. . . . . . . LITERALLY
|
||
18 SSREG. . . . . . . LITERALLY
|
||
14 0000H 1 TABLECHAR. . . . . BYTE BASED(TABLEPTR) 71 73 202
|
||
14 000CH 2 TABLEPTR . . . . . WORD 14 70 71 72 73 198 202 203
|
||
|
||
10 0000H 10 TABPTRS. . . . . . WORD ARRAY(5) PUBLIC INITIAL 198
|
||
255 0016H 2 TEMP . . . . . . . WORD 257 261
|
||
225 0201H 1 TEMP . . . . . . . BYTE 226 228
|
||
2 TRUE . . . . . . . LITERALLY 218 317 341 347 350 375 386
|
||
390 403 411 424 426 464
|
||
209 03DCH 8 TYPE1. . . . . . . PROCEDURE STACK=000AH 427
|
||
242 0451H 11 TYPE10 . . . . . . PROCEDURE STACK=0016H 434
|
||
246 045CH 11 TYPE11 . . . . . . PROCEDURE STACK=001CH 435
|
||
250 0467H 14 TYPE12 . . . . . . PROCEDURE STACK=000AH 436
|
||
254 0475H 39 TYPE13 . . . . . . PROCEDURE STACK=001CH 437
|
||
263 049CH 11 TYPE14 . . . . . . PROCEDURE STACK=0024H 438
|
||
267 04A7H 35 TYPE18 . . . . . . PROCEDURE STACK=001CH 439
|
||
212 03E4H 30 TYPE2. . . . . . . PROCEDURE STACK=000AH 428
|
||
281 04CAH 35 TYPE22 . . . . . . PROCEDURE STACK=0018H 440
|
||
295 04EDH 17 TYPE23 . . . . . . PROCEDURE STACK=0020H 441
|
||
301 04FEH 41 TYPE25 . . . . . . PROCEDURE STACK=0018H 442
|
||
315 0527H 40 TYPE27 . . . . . . PROCEDURE STACK=0020H 443
|
||
220 0402H 15 TYPE3. . . . . . . PROCEDURE STACK=0014H 429
|
||
324 054FH 46 TYPE31 . . . . . . PROCEDURE STACK=0020H 444
|
||
333 057DH 24 TYPE33 . . . . . . PROCEDURE STACK=0014H 445
|
||
339 0595H 22 TYPE34 . . . . . . PROCEDURE STACK=0020H 446
|
||
346 05ABH 62 TYPE36 . . . . . . PROCEDURE STACK=0020H 447
|
||
366 05E9H 17 TYPE38 . . . . . . PROCEDURE STACK=0020H 448
|
||
372 05FAH 35 TYPE39 . . . . . . PROCEDURE STACK=0020H 449
|
||
224 0411H 31 TYPE4. . . . . . . PROCEDURE STACK=0014H 430
|
||
383 061DH 36 TYPE40 . . . . . . PROCEDURE STACK=0020H 450
|
||
395 0641H 29 TYPE42 . . . . . . PROCEDURE STACK=0020H 451
|
||
401 065EH 41 TYPE44 . . . . . . PROCEDURE STACK=0020H 453
|
||
410 0687H 13 TYPE45 . . . . . . PROCEDURE STACK=0024H 454
|
||
230 0430H 11 TYPE5. . . . . . . PROCEDURE STACK=001CH 431
|
||
234 043BH 11 TYPE6. . . . . . . PROCEDURE STACK=001CH 432
|
||
PL/M-86 COMPILER 8086 DISASSEMBLER 5/14/81 PAGE 16
|
||
|
||
|
||
238 0446H 11 TYPE8. . . . . . . PROCEDURE STACK=0020H 412 433
|
||
13 01D0H 1 VBIT . . . . . . . BYTE 61 320
|
||
13 01D1H 1 WBIT . . . . . . . BYTE 60 64 85 96 113 327 347 406
|
||
13 01D2H 1 ZBIT . . . . . . . BYTE 60
|
||
|
||
|
||
|
||
MODULE INFORMATION:
|
||
|
||
CODE AREA SIZE = 0815H 2069D
|
||
CONSTANT AREA SIZE = 0016H 22D
|
||
VARIABLE AREA SIZE = 0203H 515D
|
||
MAXIMUM STACK SIZE = 0030H 48D
|
||
636 LINES READ
|
||
0 PROGRAM ERROR(S)
|
||
|
||
END OF PL/M-86 COMPILATION
|