seppdroid/Digital-Research-Source-Code
1
0
Fork 0
mirror of https://github.com/SEPPDROID/Digital-Research-Source-Code.git synced 2025-10-27 02:14:19 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Upload

Browse Source 
Digital Research
This commit is contained in:
Sepp J Morris
2020-11-06 18:50:37 +01:00
parent 621ed8ccaf
commit 31738079c4
8481 changed files with 1888323 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

878
CPM OPERATING SYSTEMS/CPM 86/CONCURRENT/CCPM-86 2.0 SOURCE/ddt86/dis86.lst Normal file
View File

@@ -0,0 +1,878 @@
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