Category

Development Platform
Home > SourceCode/Document > Compiler program > View Code
OUTAS68.C
Package: c_compiler.zip　[view]
Upload User: hlzzc88
Upload Date: 2007-01-06
Package Size: 220k
Code Size: 32k
Category:

Compiler program

Development Platform:

Others

OUTAS68.C：Code Content
  1. /*                         
  2.  * 68K/386 32-bit C compiler.
  3.  *
  4.  * copyright (c) 1997, David Lindauer
  5.  * 
  6.  * This compiler is intended for educational use.  It may not be used
  7.  * for profit without the express written consent of the author.
  8.  *
  9.  * It may be freely redistributed, as long as this notice remains intact
  10.  * and either the original sources or derived sources 
  11.  * are distributed along with any executables derived from the originals.
  12.  *
  13.  * The author is not responsible for any damages that may arise from use
  14.  * of this software, either idirect or consequential.
  15.  *
  16.  * v1.35 March 1997
  17.  * David Lindauer, gclind01@starbase.spd.louisville.edu
  18.  *
  19.  * Credits to Mathew Brandt for original K&R C compiler
  20.  *
  21.  */
  22. #include        <stdio.h>
  23. #include <ctype.h>
  24. #include        "expr.h"
  25. #include        "c.h"
  26. #include        "gen68.h"
  27. #include  "diag.h"
  29. /*      variable initialization         */
  30. extern int global_flag;
  31. extern SYM *currentfunc;
  32. extern HASHREC **globalhash;
  33. extern OCODE *peep_insert, *peep_head, *peep_tail;
  34. extern int prm_rel;
  35. extern long nextlabel;
  36. extern FILE *outputFile;
  37. extern int prm_asmfile;
  38. extern int prm_lines;
  39. extern int phiused;
  40. extern int prm_cmangle;
  42. enum e_gt  gentype = nogen; /* Current DC type */
  43. enum e_sg  curseg = noseg; /* Current seg */
  44. int        outcol = 0; /* Curront col (roughly) */
  45. int   dataofs; /* Offset from last label */
  46. SYM *datasp; /* Symbol of last named label */
  47. static DATALINK *datahead, *datatail; /* links for fixup gen */
  48. static int phiput;
  50. ASMREG reglst[] = {
  51. { 0 , 0 , 0 },
  52. };
  53. /* List of opcodes
  54.  * This list MUST be in the same order as the op_ enums 
  55.  */
  56. ASMNAME oplst[] = {
  57. { "?reserved",op_reserved,0 },
  58. { "?line#",op_reserved,0 },
  59. { "?seq@",op_reserved,0 },
  60. { "?slit",op_reserved,0 },
  61. { "?label",op_reserved,0 },
  62. { "?flabel",op_reserved,0 },
  63. { "dc",op_reserved,0 },
  64. { "dc",op_reserved,0 },
  65. { "dc",op_reserved,0 },
  66. { "abcd",op_abcd,0 },
  67. { "add",op_add,0 },
  68. { "adda",op_adda,0 },
  69. { "addi",op_addi,0 },
  70. { "addq",op_addq,0 },
  71. { "addx",op_addx,0 },
  72. { "and",op_and,0 },
  73. { "andi",op_andi,0 },
  74. { "asl",op_asl,0 },
  75. { "asr",op_asr,0 },
  76. { "bra",op_bra,0 },
  77. { "beq",op_beq,0 },
  78. { "bne",op_bne,0 },
  79. { "blt",op_blt,0 },
  80. { "ble",op_ble,0 },
  81. { "bgt",op_bgt,0 },
  82. { "bge",op_bge,0 },
  83. { "bhi",op_bhi,0 },
  84. { "bhs",op_bhs,0 },
  85. { "blo",op_blo,0 },
  86. { "bls",op_bls,0 },
  87. { "bsr",op_bsr,0 },
  88. { "bcc", op_bcc,0 },
  89. { "bcs", op_bcs,0 },
  90. { "bmi", op_bmi,0 },
  91. { "bpl", op_bpl,0 },
  92. { "bvc", op_bvc,0 },
  93. { "bvs", op_bvs,0 },
  94. { "bchg",op_bchg,0 },
  95. { "bclr",op_bclr,0 },
  96. { "bfchg",op_bfchg,0 },
  97. { "bfclr",op_bfclr,0 },
  98. { "bfexts",op_bfexts,0 },
  99. { "bfextu",op_bfextu,0 },
  100. { "bfffo",op_bfffo,0 },
  101. { "bfins",op_bfins,0 },
  102. { "bfset",op_bfset,0 },
  103. { "bftst",op_bftst,0 },
  104. { "bkpt", op_bkpt,0 },
  105. { "bset",op_bset,0 },
  106. { "btst",op_btst,0 },
  107. { "chk",op_chk,0 },
  108. { "chk2",op_chk2,0 },
  109. { "clr",op_clr,0 },
  110. { "cmp",op_cmp,0 },
  111. { "cmpa",op_cmpa,0 },
  112. { "cmpi",op_cmpi,0 },
  113. { "cmpm",op_cmpm,0 },
  114. { "cmp2",op_cmp2,0 },
  115. { "dbeq",op_dbeq,0 },
  116. { "dbne",op_dbne,0 },
  117. { "dblt",op_dblt,0 },
  118. { "dble",op_dble,0 },
  119. { "dbgt",op_dbgt,0 },
  120. { "dbge",op_dbge,0 },
  121. { "dbhi",op_dbhi,0 },
  122. { "dbhs",op_dbhs,0 },
  123. { "dblo",op_dblo,0 },
  124. { "dbls",op_dbls,0 },
  125. { "dbsr",op_dbsr,0 },
  126. { "dbcc", op_dbcc,0 },
  127. { "dbcs", op_dbcs,0 },
  128. { "dbmi", op_dbmi,0 },
  129. { "dbpl", op_dbpl,0 },
  130. { "dbvc", op_dbvc,0 },
  131. { "dbvs", op_dbvs,0 },
  132. { "dbt", op_dbt,0 },
  133. { "dbf", op_dbf,0 },
  134. { "dbra",op_dbra,0 },
  135. { "divs",op_divs,0 },
  136. { "divu",op_divu,0 },
  137. { "divsl",op_divsl,0 },
  138. { "divul",op_divul,0 },
  139. { "eor",op_eor,0 },
  140. { "eori",op_eori,0 },
  141. { "exg",op_exg,0 },
  142. { "ext",op_ext,0 },
  143. { "extb",op_extb,0 },
  144. { "illegal", op_illegal, 0 },
  145. { "jmp",op_jmp,0 },
  146. { "jsr",op_jsr,0 },
  147. { "lea",op_lea,0 },
  148. { "link",op_link,0 },
  149. { "lsl",op_lsl,0 },
  150. { "lsr",op_lsr,0 },
  151. { "move",op_move,0 },
  152. { "movea",op_movea,0 },
  153. { "movec",op_movec,0 },
  154. { "movem",op_movem,0 },
  155. { "movep",op_movep,0 },
  156. { "moveq",op_moveq,0 },
  157. { "moves",op_moves,0 },
  158. { "muls",op_muls,0 },
  159. { "mulu",op_mulu,0 },
  160. { "nbcd",op_nbcd,0 },
  161. { "neg",op_neg,0 },
  162. { "negx",op_negx,0 },
  163. { "nop",op_nop,0 },
  164. { "not",op_not,0 },
  165. { "or",op_or,0 },
  166. { "ori",op_ori,0 },
  167. { "pack",op_pack,0 },
  168. { "pea",op_pea,0 },
  169. { "reset",op_reset,0 },
  170. { "rol",op_rol,0 },
  171. { "ror",op_ror,0 },
  172. { "roxl",op_roxl,0 },
  173. { "roxr",op_roxr,0 },
  174. { "rtd",op_rtd,0 },
  175. { "rte",op_rte,0 },
  176. { "rtr",op_rtr,0 },
  177. { "rts",op_rts,0 },
  178. { "sbcd",op_sbcd,0 },
  179. { "seteq",op_seteq,0 },
  180. { "setne",op_setne,0 },
  181. { "setlt",op_setlt,0 },
  182. { "setle",op_setle,0 },
  183. { "setgt",op_setgt,0 },
  184. { "setge",op_setge,0 },
  185. { "sethi",op_sethi,0 },
  186. { "seths",op_seths,0 },
  187. { "setlo",op_setlo,0 },
  188. { "setls",op_setls,0 },
  189. { "setsr",op_setsr,0 },
  190. { "setcc", op_setcc,0 },
  191. { "setcs", op_setcs,0 },
  192. { "setmi", op_setmi,0 },
  193. { "setpl", op_setpl,0 },
  194. { "setvc", op_setvc,0 },
  195. { "setvs", op_setvs,0 },
  196. { "sett", op_sett,0 },
  197. { "setf", op_setf,0 },
  198. { "sub",op_sub,0 },
  199. { "stop",op_stop,0 },
  200. { "suba",op_suba,0 },
  201. { "subi",op_subi,0 },
  202. { "subq",op_subq,0 },
  203. { "subx",op_subx,0 },
  204. { "swap",op_swap,0 },
  205. { "tas",op_tas,0 },
  206. { "trap",op_trap,0 },
  207. { "trapeq",op_trapeq,0 },
  208. { "trapne",op_trapne,0 },
  209. { "traplt",op_traplt,0 },
  210. { "traple",op_traple,0 },
  211. { "trapgt",op_trapgt,0 },
  212. { "trapge",op_trapge,0 },
  213. { "traphi",op_traphi,0 },
  214. { "traphs",op_traphs,0 },
  215. { "traplo",op_traplo,0 },
  216. { "trapls",op_trapls,0 },
  217. { "trapsr",op_trapsr,0 },
  218. { "trapcc", op_trapcc,0 },
  219. { "trapcs", op_trapcs,0 },
  220. { "trapmi", op_trapmi,0 },
  221. { "trappl", op_trappl,0 },
  222. { "trapvc", op_trapvc,0 },
  223. { "trapvs", op_trapvs,0 },
  224. { "trapt", op_trapt,0 },
  225. { "trapf", op_trapf,0 },
  226. { "trapv", op_trapv,0 },
  227. { "tst",op_tst,0 },
  228. { "unlk",op_unlk,0 },
  229. { "unpk",op_unpk,0 },
  230. { "fabs",op_fabs,0 },
  231. { "facos",op_facos,0 },
  232. { "fadd",op_fadd,0 },
  233. { "fasin",op_fasin,0 },
  234. { "fatan",op_fatan,0 },
  235. { "fatanh",op_fatanh,0 },
  236. { "fbeq", op_fbeq, 0 },
  237. { "fbne", op_fbne, 0 },
  238. { "fbgt", op_fbgt, 0 },
  239. { "fbngt", op_fbngt, 0 },
  240. { "fbge", op_fbge, 0 },
  241. { "fbnge", op_fbnge, 0 },
  242. { "fblt", op_fblt, 0 },
  243. { "fbnlt", op_fbnlt, 0 },
  244. { "fble", op_fble, 0 },
  245. { "fbnle", op_fbnle, 0 },
  246. { "fbgl", op_fbgl, 0 },
  247. { "fbngl", op_fbngl, 0 },
  248. { "fbgle", op_fbgle, 0 },
  249. { "fbngle", op_fbngle, 0 },
  250. { "fbogt", op_fbogt, 0 },
  251. { "fbule", op_fbule, 0 },
  252. { "fboge", op_fboge, 0 },
  253. { "fbult", op_fbult, 0 },
  254. { "fbolt", op_fbolt, 0 },
  255. { "fbuge", op_fbuge, 0 },
  256. { "fbole", op_fbole, 0 },
  257. { "fbugt", op_fbugt, 0 },
  258. { "fbogl", op_fbogl, 0 },
  259. { "fbueq", op_fbueq, 0 },
  260. { "fbor", op_fbor, 0 },
  261. { "fbun", op_fbun, 0 },
  262. { "fbt", op_fbt, 0 },
  263. { "fbf", op_fbf, 0 },
  264. { "fbst", op_fbst, 0 },
  265. { "fbsf", op_fbsf, 0 },
  266. { "fbseq", op_fbseq, 0 },
  267. { "fbsne", op_fbsne, 0 },
  268. { "fcmp",op_fcmp,0 },
  269. { "fcos",op_fcos,0 },
  270. { "fcosh",op_fcosh,0 },
  271. { "fdbeq", op_fdbeq, 0 },
  272. { "fdbne", op_fdbne, 0 },
  273. { "fdbgt", op_fdbgt, 0 },
  274. { "fdbngt", op_fdbngt, 0 },
  275. { "fdbge", op_fdbge, 0 },
  276. { "fdbnge", op_fdbnge, 0 },
  277. { "fdblt", op_fdblt, 0 },
  278. { "fdbnlt", op_fdbnlt, 0 },
  279. { "fdble", op_fdble, 0 },
  280. { "fdbnle", op_fdbnle, 0 },
  281. { "fdbgl", op_fdbgl, 0 },
  282. { "fdbngl", op_fdbngl, 0 },
  283. { "fdbgle", op_fdbgle, 0 },
  284. { "fdbngle", op_fdbngle, 0 },
  285. { "fdbogt", op_fdbogt, 0 },
  286. { "fdbule", op_fdbule, 0 },
  287. { "fdboge", op_fdboge, 0 },
  288. { "fdbult", op_fdbult, 0 },
  289. { "fdbolt", op_fdbolt, 0 },
  290. { "fdbuge", op_fdbuge, 0 },
  291. { "fdbole", op_fdbole, 0 },
  292. { "fdbugt", op_fdbugt, 0 },
  293. { "fdbogl", op_fdbogl, 0 },
  294. { "fdbueq", op_fdbueq, 0 },
  295. { "fdbor", op_fdbor, 0 },
  296. { "fdbun", op_fdbun, 0 },
  297. { "fdbt", op_fdbt, 0 },
  298. { "fdbf", op_fdbf, 0 },
  299. { "fdbst", op_fdbst, 0 },
  300. { "fdbsf", op_fdbsf, 0 },
  301. { "fdbseq", op_fdbseq, 0 },
  302. { "fdbsne", op_fdbsne, 0 },
  303. { "fdiv",op_fdiv,0 },
  304. { "fetox",op_fetox,0 },
  305. { "fetoxm1",op_fetoxm1,0 },
  306. { "fgetexp",op_fgetexp,0 },
  307. { "fgetman",op_fgetman,0 },
  308. { "fint",op_fint,0 },
  309. { "fintrz",op_fintrz,0 },
  310. { "flog10",op_flog10,0 },
  311. { "flog2",op_flog2,0 },
  312. { "flogn",op_flogn,0 },
  313. { "flognp1",op_flognp1,0 },
  314. { "fmod",op_fmod,0 },
  315. { "fmove",op_fmove,0 },
  316. { "fmovecr",op_fmovecr,0 },
  317. { "fmovem",op_fmovem,0 },
  318. { "fmul",op_fmul,0 },
  319. { "fneg",op_fneg,0 },
  320. { "fnop",op_fnop,0 },
  321. { "frem",op_frem,0 },
  322. { "fscale",op_fscale,0 },
  323. { "fseq", op_fseq, 0 },
  324. { "fsne", op_fsne, 0 },
  325. { "fsgt", op_fsgt, 0 },
  326. { "fsngt", op_fsngt, 0 },
  327. { "fsge", op_fsge, 0 },
  328. { "fsnge", op_fsnge, 0 },
  329. { "fslt", op_fslt, 0 },
  330. { "fsnlt", op_fsnlt, 0 },
  331. { "fsle", op_fsle, 0 },
  332. { "fsnle", op_fsnle, 0 },
  333. { "fsgl", op_fsgl, 0 },
  334. { "fsngl", op_fsngl, 0 },
  335. { "fsgle", op_fsgle, 0 },
  336. { "fsngle", op_fsngle, 0 },
  337. { "fsogt", op_fsogt, 0 },
  338. { "fsule", op_fsule, 0 },
  339. { "fsoge", op_fsoge, 0 },
  340. { "fsult", op_fsult, 0 },
  341. { "fsolt", op_fsolt, 0 },
  342. { "fsuge", op_fsuge, 0 },
  343. { "fsole", op_fsole, 0 },
  344. { "fsugt", op_fsugt, 0 },
  345. { "fsogl", op_fsogl, 0 },
  346. { "fsueq", op_fsueq, 0 },
  347. { "fsor", op_fsor, 0 },
  348. { "fsun", op_fsun, 0 },
  349. { "fst", op_fst, 0 },
  350. { "fsf", op_fsf, 0 },
  351. { "fsst", op_fsst, 0 },
  352. { "fssf", op_fssf, 0 },
  353. { "fsseq", op_fsseq, 0 },
  354. { "fssne", op_fssne, 0 },
  355. { "fsgldiv",op_fsgldiv,0 },
  356. { "fsglmul",op_fsglmul,0 },
  357. { "fsin",op_fsin,0 },
  358. { "fsincos",op_fsincos,0 },
  359. { "fsinh",op_fsinh,0 },
  360. { "fsqrt",op_fsqrt,0 },
  361. { "fsub",op_fsub,0 },
  362. { "ftan",op_ftan,0 },
  363. { "ftanh",op_ftanh,0 },
  364. { "ftentox",op_ftentox,0 },
  365. { "ftrapeq", op_ftrapeq, 0 },
  366. { "ftrapne", op_ftrapne, 0 },
  367. { "ftrapgt", op_ftrapgt, 0 },
  368. { "ftrapngt", op_ftrapngt, 0 },
  369. { "ftrapge", op_ftrapge, 0 },
  370. { "ftrapnge", op_ftrapnge, 0 },
  371. { "ftraplt", op_ftraplt, 0 },
  372. { "ftrapnlt", op_ftrapnlt, 0 },
  373. { "ftraple", op_ftraple, 0 },
  374. { "ftrapnle", op_ftrapnle, 0 },
  375. { "ftrapgl", op_ftrapgl, 0 },
  376. { "ftrapngl", op_ftrapngl, 0 },
  377. { "ftrapgle", op_ftrapgle, 0 },
  378. { "ftrapngle", op_ftrapngle, 0 },
  379. { "ftrapogt", op_ftrapogt, 0 },
  380. { "ftrapule", op_ftrapule, 0 },
  381. { "ftrapoge", op_ftrapoge, 0 },
  382. { "ftrapult", op_ftrapult, 0 },
  383. { "ftrapolt", op_ftrapolt, 0 },
  384. { "ftrapuge", op_ftrapuge, 0 },
  385. { "ftrapole", op_ftrapole, 0 },
  386. { "ftrapugt", op_ftrapugt, 0 },
  387. { "ftrapogl", op_ftrapogl, 0 },
  388. { "ftrapueq", op_ftrapueq, 0 },
  389. { "ftrapor", op_ftrapor, 0 },
  390. { "ftrapun", op_ftrapun, 0 },
  391. { "ftrapt", op_ftrapt, 0 },
  392. { "ftrapf", op_ftrapf, 0 },
  393. { "ftrapst", op_ftrapst, 0 },
  394. { "ftrapsf", op_ftrapsf, 0 },
  395. { "ftrapseq", op_ftrapseq, 0 },
  396. { "ftrapsne", op_ftrapsne, 0 },
  397. { "ftst",op_ftst,0 },
  398. { "ftwotox",op_ftwotox,0 },
  399. { 0,0,0 },
  400.  };
  401. /* Init module */
  402. void outcodeini(void)
  403. {
  404. gentype = nogen;
  405. curseg = noseg;
  406. outcol = 0;
  407. datahead = datatail = 0;   
  408. phiput = FALSE;
  409. }
  410. /*
  411.  * Register a fixup 
  412.  */
  413. void datalink(int flag)
  414. {
  415. DATALINK *p;
  416. if (!prm_rel)
  417. return;
  418. global_flag++; /* Global tab */
  419. p = xalloc(sizeof(DATALINK));
  420. p->sp = datasp;
  421. p->type = flag;
  422. p->offset = dataofs;
  423. p->next = 0;
  424. if (datahead) {
  425. datatail->next = p;
  426. datatail=datatail->next;
  427. }
  428. else
  429. datahead = datatail = p;
  430. global_flag--;
  431. }
  432. void nl(void)
  433. /*
  434.  * New line
  435.  */
  436. {    if (prm_asmfile) {
  437.        if(outcol > 0) {
  438.                 fputc('n',outputFile);
  439.                 outcol = 0;
  440.                 gentype = nogen;
  441.                 }
  442.  if (phiused && !phiput)
  443. fputc(0x1f,outputFile);
  444.  }
  445. }
  446. /* Put an opcode
  447.  */
  448. void outop(char *name)
  449. {
  450. fputc('t',outputFile);
  451. while (*name)
  452. fputc(toupper(*name++),outputFile);
  453. }
  454. void putop(int op)
  455. {       
  456. if (op > op_ftwotox)
  457.     DIAG("illegal opcode.");
  458. else
  459. outop(oplst[op].word);
  460. }
  462. void putconst(ENODE *offset)
  463. /*
  464.  *      put a constant to the outputFile file.
  465.  */
  466. {       switch( offset->nodetype )
  467.                 {
  468. case en_autoreg:
  469.                 case en_autocon:
  470.                 case en_icon:
  471.                 case en_lcon:
  472.                 case en_iucon:
  473.                 case en_lucon:
  474.                 case en_ccon:
  475. case en_absacon:
  476.                         fprintf(outputFile,"$%lX",offset->v.i);
  477. break;
  478. case en_rcon:
  479. case en_fcon:
  480. case en_lrcon:
  481. fprintf(outputFile,"%f",offset->v.f);
  482. break;
  483.                 case en_labcon:
  484.                 case en_nalabcon:
  485.                         fprintf(outputFile,"L_%ld",offset->v.i);
  486.                         break;
  487. case en_napccon:
  488.                 case en_nacon:
  489.                         fprintf(outputFile,"%s",offset->v.p[0]);
  490.                         break;
  491.                 case en_add:
  492.                         putconst(offset->v.p[0]);
  493.                         fprintf(outputFile,"+");
  494.                         putconst(offset->v.p[1]);
  495.                         break;
  496.                 case en_sub:
  497.                         putconst(offset->v.p[0]);
  498.                         fprintf(outputFile,"-");
  499.                         putconst(offset->v.p[1]);
  500.                         break;
  501.                 case en_uminus:
  502.                         fprintf(outputFile,"-");
  503.                         putconst(offset->v.p[0]);
  504.                         break;
  505.                 default:
  506.                         DIAG("illegal constant node.");
  507.                         break;
  508.                 }
  509. }
  510. void putlen(int l)
  511. /*
  512.  *      append the length field to an instruction.
  513.  */
  514. {       switch( l )
  515.                 {
  516.                 case 0:
  517.                         break;  /* no length field */
  518.                 case 1:
  519.                         fprintf(outputFile,".B");
  520.                         break;
  521.                 case 2:
  522.                         fprintf(outputFile,".W");
  523.                         break;
  524.                 case 4:
  525.                         fprintf(outputFile,".L");
  526.                         break;
  527. case 6:
  528. fprintf(outputFile,".S");
  529. break;
  530. case 8:
  531. fprintf(outputFile,".D");
  532. break;
  533. case 10:
  534. fprintf(outputFile,".X");
  535. break;
  536.                 default:
  537.                         DIAG("illegal length field.");
  538.                         break;
  539.                 }
  540. }
  542. void putamode(AMODE *ap)
  543. /*
  544.  *      outputFile a general addressing mode.
  545.  */
  546. {       int scale,t;
  547. switch( ap->mode )
  548.                 {
  549. case am_sr:
  550. fprintf(outputFile, "SR");
  551. break;
  552. case am_bf:
  553. fprintf(outputFile," {%d:%d}",ap->preg,ap->sreg);
  554. break;
  555. case am_divsl:
  556. fprintf(outputFile,"D%d:D%d",ap->preg, ap->sreg);
  557. break;
  558.                 case am_immed:
  559.                         fprintf(outputFile,"#");
  560.                 case am_direct:
  561.                         putconst(ap->offset);
  562.                         break;
  563.                 case am_adirect:
  564. fputc('(',outputFile);
  565.                         putconst(ap->offset);
  566. fputc(')',outputFile);
  567. putlen(ap->preg);
  568.                         break;
  569.                 case am_areg:
  570.                         fprintf(outputFile,"A%d",ap->preg);
  571.                         break;
  572.                 case am_dreg:
  573.                         fprintf(outputFile,"D%d",ap->preg);
  574.                         break;
  575. case am_freg:
  576. fprintf(outputFile,"FP%d",ap->preg);
  577. break;
  578.                 case am_ind:
  579.                         fprintf(outputFile,"(A%d)",ap->preg);
  580.                         break;
  581.                 case am_ainc:
  582.                         fprintf(outputFile,"(A%d)+",ap->preg);
  583.                         break;
  584.                 case am_adec:
  585.                         fprintf(outputFile,"-(A%d)",ap->preg);
  586.                         break;
  587.                 case am_indx:
  588.                         fprintf(outputFile,"(");
  589.                         putconst(ap->offset);
  590.                         fprintf(outputFile,",A%d)",ap->preg);
  591.                         break;
  592. case am_pcindx:
  593.                         fprintf(outputFile,"(");
  594.                         putconst(ap->offset);
  595.                         fprintf(outputFile,",PC)");
  596.                         break;
  597.                 case am_baseindxdata:
  598. scale = 1;
  599. t = ap->scale;
  600. while (t--)
  601. scale <<=1;
  602.                         fprintf(outputFile,"(");
  603.                         putconst(ap->offset);
  604. if (ap->preg != -1)
  605.                          fprintf(outputFile,",A%d",ap->preg);
  606.                         fprintf(outputFile,",D%d.L",ap->sreg);
  607. if (scale != 1)
  608. fprintf(outputFile,"*%d",scale);
  609. fputc(')', outputFile);
  610.                         break;
  611.                 case am_baseindxaddr:
  612. scale = 1;
  613. t = ap->scale;
  614. while (t--)
  615. scale <<=1;
  616.                         fprintf(outputFile,"(");
  617.                         putconst(ap->offset);
  618. if (ap->preg != -1)
  619.                          fprintf(outputFile,",A%d",ap->preg);
  620.                         fprintf(outputFile,",A%d.L",ap->sreg);
  621. if (scale != 1)
  622. fprintf(outputFile,"*%d",scale);
  623. fputc(')', outputFile);
  624.                         break;
  625.                 case am_mask:
  626.                         put_mask((int)ap->offset, ap->preg);
  627.                         break;
  628. case am_fmask:
  629.                         put_fmask((int)ap->offset, ap->preg);
  630.                         break;
  631.                 default:
  632.                         DIAG("illegal address mode.");
  633.                         break;
  634.                 }
  635. }
  637. void put_code(OCODE *cd)
  638. /*
  639.  *      outputFile a generic instruction.
  640.  */
  641. {    
  642. int op = cd->opcode,len = cd->length;
  643. AMODE *aps = cd->oper1,*apd = cd->oper2, *ape = cd->oper3;   
  644. nl();
  645. if (!prm_asmfile) {
  646. ;/* oc_putop(cd); */
  647. return;
  648. }
  649. if (op == op_line) {
  650. if (!prm_lines)
  651. return;
  652. fprintf(outputFile,";n; Line %d:t%sn;n",len,(char *)aps);
  653. return;
  654. }
  655. if (op == op_slit) {
  656. int l =genstring((char *)cd->oper1,(int)cd->oper2);
  657. if ((int)cd->oper2)
  658. genword(0);
  659. else {
  660. if (!(l & 1))
  661. genbyte(0);
  662. genbyte(0);
  663. }
  664. return;
  665. }
  666. if( op == op_dcl)
  667. {
  668. putop(op);
  669. putlen(len);
  670.       fprintf(outputFile,"t");
  671. putamode(aps);
  672. if (prm_rel)
  673. fprintf(outputFile,"-*");
  674.       fprintf(outputFile,"n");
  675. return;
  676. }
  677. else
  678. {
  679. putop(op);
  680.       putlen(len);
  681. }
  682.     if( aps != 0 )
  683.     {
  684.       fprintf(outputFile,"t");
  685. putamode(aps);
  686.       if( apd != 0 )
  687.       {
  688. if (apd->mode != am_bf)
  689.           fprintf(outputFile,",");
  690.         putamode(apd);
  691. if (ape) {
  692. if (ape->mode != am_bf)
  693. fprintf(outputFile,",");
  694. putamode(ape);
  695. }
  696.       }
  697.     }
  698.   fprintf(outputFile,"n");
  699. }
  701. void put_fmask(int mask, int reverse)
  702. /*
  703.  *      generate a register mask for floating restore and save.
  704.  */
  705. {
  706. unsigned put = FALSE,i,bit;
  707. if (!reverse) {
  708. bit = 0x80;
  709. for (i=0; i < 8; i++) {
  710. if (bit & (unsigned) mask) {
  711. if (put)
  712. fputc('/', outputFile);
  713. put = TRUE;
  714. putreg(i+16);
  715. }
  716.   bit >>= 1;
  717. }
  719. }
  720. else{
  721.   bit = 1;
  722. for (i=0; i < 8; i++) {
  723. if (bit & (unsigned)mask) {
  724. if (put)
  725. fputc('/', outputFile);
  726. put = TRUE;
  727. putreg(i+16);
  728. }
  729. bit <<= 1;
  730. }
  731. }
  732. }
  733. void put_mask(int mask, int reverse)
  734. /*
  735.  *      generate a register mask for integer restore and save.
  736.  */
  737. {
  738. unsigned put = FALSE,i,bit;
  739. if (!reverse) {
  740. bit = 0x8000;
  741. for (i=0; i < 16; i++) {
  742. if (bit & (unsigned) mask) {
  743. if (put)
  744. fputc('/', outputFile);
  745. put = TRUE;
  746. putreg(i);
  747. }
  748.   bit >>= 1;
  749. }
  751. }
  752. else{
  753.   bit = 1;
  754. for (i=0; i < 16; i++) {
  755. if (bit & (unsigned)mask) {
  756. if (put)
  757. fputc('/', outputFile);
  758. put = TRUE;
  759. putreg(i);
  760. }
  761. bit <<= 1;
  762. }
  763. }
  764. }
  766. void putreg(int r)
  767. /*
  768.  *      generate a register name from a tempref number.
  769.  */
  770. {       if( r < 8 )
  771.                 fprintf(outputFile,"D%d",r);
  772.         else if (r <16)
  773.                 fprintf(outputFile,"A%d",r - 8);
  774. else fprintf(outputFile,"FP%d",r-16);
  775. }
  777. void gen_strlab(SYM *sp)
  778. /*
  779.  *      generate a named label.
  780.  */
  781. {
  782. datasp = sp;
  783. if (prm_asmfile) {
  784. nl();
  785. if (curseg == codeseg && currentfunc->pascaldefn) {
  786. char buf[100],*q=buf,*p=sp->name;
  787. if (prm_cmangle)
  788. p++;
  789. while(*p)
  790. *q++=toupper(*p++);
  791. *q++ = 0;
  792.          fprintf(outputFile,"%s:n",buf);
  793. }
  794. else
  795.          fprintf(outputFile,"%s:n",sp->name);
  796. }
  797. else
  798. ;/* oc_namedlab(sp); */
  799. dataofs = 0;
  800. }
  802. void put_label(OCODE *cd)
  803. /*
  804.  *      outputFile a compiler generated label.
  805.  */
  806. {
  807.         if (prm_asmfile) {
  808. nl();
  809. fprintf(outputFile,"L_%ld:n",(long)(cd->oper1));
  810. }
  811. else
  812. ;/* oc_unnamedlab(cd); */
  813. }
  814. void put_staticlabel(long label)
  815. {
  816. if (prm_asmfile) {
  817. nl();
  818. fprintf(outputFile,"L_%ld:n",label);
  819. }
  820. }
  822. void genfloat(float val)
  823. /*
  824.  * Output a float value
  825.  */
  826. {  if (prm_asmfile)
  827.         if( gentype == floatgen && outcol < 60) {
  828.                 fprintf(outputFile,",%f",val);
  829.                 outcol += 8;
  830.                 }
  831.         else    {
  832.                 nl();
  833.                 fprintf(outputFile,"tDC.St%f",val);
  834.                 gentype = floatgen;
  835.                 outcol = 19;
  836.                 }
  837. else
  838. ;/* oc_genfloat(val); */
  839. dataofs+=4;
  840. }
  842. void gendouble(double val)
  843. /*
  844.  * Output a double value
  845.  */
  846. {  if (prm_asmfile)
  847.         if( gentype == doublegen && outcol < 60) {
  848.                 fprintf(outputFile,",%f",val);
  849.                 outcol += 8;
  850.                 }
  851.         else    {
  852.                 nl();
  853.                 fprintf(outputFile,"tDC.Dt%f",val);
  854.                 gentype = doublegen;
  855.                 outcol = 19;
  856.                 }
  857. else
  858. ;/* oc_gendouble(val); */
  859. dataofs+=8;
  860. }
  861. void genlongdouble(long double val)
  862. /*
  863.  * Output a double value
  864.  */
  865. {  if (prm_asmfile)
  866.         if( gentype == longdoublegen && outcol < 60) {
  867.                 fprintf(outputFile,",%f",val);
  868.                 outcol += 8;
  869.                 }
  870.         else    {
  871.                 nl();
  872.                 fprintf(outputFile,"tDTt%f",val);
  873.                 gentype = longdoublegen;
  874.                 outcol = 19;
  875.                 }
  876. else
  877. ;/* oc_genlongdouble(val); */
  878. dataofs+=8;
  879. }
  881. int genstring(char *str, int uselong)
  882. /*
  883.  * Generate a string literal
  884.  */
  885. {
  886. if (uselong) {
  887. while  (*(short *)str) {
  888. genword(*((short *)str));
  889. str += sizeof(short);
  890. }
  891. genword(0);
  892. return pstrlen(str)*2;
  893. }
  894. else {
  895. int size = 0;
  896. while (*str) {
  897. genbyte(*str++);
  898. size++;
  899. }
  900. return size;
  901. }
  902. }
  903. void genbyte(long val)
  904. /*
  905.  * Output a byte value
  906.  */
  907. {  if (prm_asmfile)
  908.         if( gentype == bytegen && outcol < 60) {
  909.                 fprintf(outputFile,",$%X",val & 0x00ff);
  910.                 outcol += 4;
  911.                 }
  912.         else    {
  913.                 nl();
  914.                 fprintf(outputFile,"tDC.Bt$%X",val & 0x00ff);
  915.                 gentype = bytegen;
  916.                 outcol = 19;
  917.                 }
  918. else
  919. ;/* oc_genbyte(val); */
  920. dataofs+=1;
  921. }
  923. void genword(long val)
  924. /*
  925.  * Output a word value
  926.  */
  927. {     if (prm_asmfile)
  928.         if( gentype == wordgen && outcol < 58) {
  929.                 fprintf(outputFile,",$%X",val & 0x0ffff);
  930.                 outcol += 6;
  931.                 }
  932.         else    {
  933.                 nl();
  934.                 fprintf(outputFile,"tDC.Wt$%X",val & 0x0ffff);
  935.                 gentype = wordgen;
  936.                 outcol = 21;
  937.                 }
  938. else
  939. ;/* oc_genword(val); */
  940. dataofs+=2;
  941. }
  943. void genlong(long val)
  944. /*
  945.  * Output a long value
  946.  */
  947. {     if (prm_asmfile)
  948.         if( gentype == longgen && outcol < 56) {
  949.                 fprintf(outputFile,",$%lX",val);
  950.                 outcol += 10;
  951.                 }
  952.         else    {
  953.                 nl();
  954.                 fprintf(outputFile,"tDC.Lt$%lX",val);
  955.                 gentype = longgen;
  956.                 outcol = 25;
  957.                 }
  958. else
  959. ;/* oc_genlong(val); */
  960. dataofs+=4;
  961. }
  962. /*
  963.  * Generate a startup or rundown reference
  964.  */
  965. void gensrref(SYM *sp,int val)
  966. {
  967. if (prm_asmfile)
  968.         if( gentype == srrefgen && outcol < 56) {
  969.                 fprintf(outputFile,",%s,%d",sp->name,val);
  970.                 outcol += strlen(sp->name)+1;
  971.                 }
  972.         else    {
  973.                 nl();
  974.                 fprintf(outputFile,"tDC.Lt%s,%d",sp->name,val);
  975.                 gentype = srrefgen;
  976.                 outcol = 25;
  977.                 }
  978. else 
  979. ;/* oc_gensrref(sp,val); */
  980. }
  982. void genref(SYM *sp,int offset)
  983. /*
  984.  * Output a reference to the data area (also gens fixups )
  985.  */
  986. {       char    sign;
  987. char buf[40];
  988.         if( offset < 0) {
  989.                 sign = '-';
  990.                 offset = -offset;
  991.                 }
  992.         else
  993.                 sign = '+';
  994. sprintf(buf,"%s%c%d",sp->name,sign,offset);
  995. datalink(FALSE);
  996. if (prm_asmfile) {
  997.         if( gentype == longgen && outcol < 55 - strlen(sp->name)) {
  998.                 fprintf(outputFile,",%s",buf);
  999.                 outcol += (11 + strlen(sp->name));
  1000.                 }
  1001.         else    {
  1002.                 nl();
  1003.                 fprintf(outputFile,"tDC.Lt%s",buf);
  1004.                 outcol = 26 + strlen(sp->name);
  1005.                 gentype = longgen;
  1006.                 }
  1007. }
  1008. else
  1009. ;/* oc_genref(sp,val); */
  1010. dataofs+=4;
  1011. }
  1012. void genpcref(SYM *sp,int offset)
  1013. /*
  1014.  * Output a reference to the code area (also gens fixups )
  1015.  */
  1016. {       char    sign;
  1017. char buf[40];
  1018.         if( offset < 0) {
  1019.                 sign = '-';
  1020.                 offset = -offset;
  1021.                 }
  1022.         else
  1023.                 sign = '+';
  1024. sprintf(buf,"%s%c%d",sp->name,sign,offset);
  1025. datalink(TRUE);
  1026. if (prm_asmfile) {
  1027.         if( gentype == longgen && outcol < 55 - strlen(sp->name)) {
  1028.                 fprintf(outputFile,",%s",buf);
  1029.                 outcol += (11 + strlen(sp->name));
  1030.                 }
  1031.         else    {
  1032.                 nl();
  1033.                 fprintf(outputFile,"tDC.Lt%s",buf);
  1034.                 outcol = 26 + strlen(sp->name);
  1035.                 gentype = longgen;
  1036.                 }
  1037. }
  1038. else
  1039. ;/* oc_genpcref(sp,val); */
  1040. dataofs+=4;
  1041. }
  1043. void genstorage(int nbytes)
  1044. /*
  1045.  * Output bytes of storage
  1046.  */
  1047. { if (prm_asmfile) {
  1048.         nl();
  1049.         fprintf(outputFile,"tDS.Bt$%Xn",nbytes);
  1050. }
  1051. else
  1052. ;/* oc_genstorage(nbytes); */
  1053. dataofs+=nbytes;
  1054. }
  1056. void gen_labref(int n)
  1057. /*
  1058.  * Generate a reference to a label
  1059.  */
  1060. { if (prm_asmfile)
  1061.         if( gentype == longgen && outcol < 58) {
  1062.                 fprintf(outputFile,",L_%d",n);
  1063.                 outcol += 6;
  1064.                 }
  1065.         else    {
  1066.                 nl();
  1067.                 fprintf(outputFile,"tDC.LtL_%d",n);
  1068.                 outcol = 22;
  1069.                 gentype = longgen;
  1070.                 }
  1071. else
  1072. ;/* oc_genlabref(n); */
  1073. datalink(TRUE);
  1074. dataofs+=4;
  1075. }
  1077. int     stringlit(char *s, int uselong)
  1078. /*
  1079.  *      make s a string literal and return it's label number.
  1080.  */
  1081. {       OCODE     *ip;
  1082. ip = xalloc(sizeof(OCODE));
  1083. ip->opcode = op_label;
  1084. ip->oper1 = (AMODE *)nextlabel;
  1085.         ip->back = 0;
  1086. if (!peep_head) 
  1087. peep_head = peep_tail = peep_insert = ip;
  1088. else {
  1089. if (peep_insert->fwd) {
  1090. peep_insert->fwd->back = ip;
  1091. }
  1092. ip->back = peep_insert;
  1093. ip->fwd = peep_insert->fwd;
  1094. if (peep_tail == peep_insert)
  1095. peep_tail = ip;
  1096. peep_insert = peep_insert->fwd = ip;
  1097. }
  1098.         ip = xalloc(sizeof(OCODE));
  1099. ip->opcode = op_slit;
  1100. if (uselong) {
  1101.          ip->oper1 = plitlate(s);
  1102. ip->oper2 = (AMODE *)1;
  1103. }
  1104. else {
  1105.          ip->oper1 = litlate(s);
  1106. ip->oper2 = 0;
  1107. }
  1108. if (peep_insert->fwd)
  1109. peep_insert->fwd->back = ip;
  1110. ip->back = peep_insert;
  1111. ip->fwd = peep_insert->fwd;
  1112. if (peep_tail == peep_insert)
  1113. peep_tail = ip;
  1114. peep_insert = peep_insert->fwd = ip;
  1116.         return nextlabel++;
  1117. }
  1118. void dumplits(void)
  1119. {
  1120. }
  1122. /*
  1123.  * Switch to cseg 
  1124.  */
  1125. void cseg(void)
  1126. { if (prm_asmfile)
  1127.         if( curseg != codeseg) {
  1128.                 nl();
  1129.                 fprintf(outputFile,"tSECTIONtcoden");
  1130.                 curseg = codeseg;
  1131.                 }
  1132. }
  1133. /*
  1134.  * Switch to dseg
  1135.  */
  1136. void dseg(void)
  1137. {     if (prm_asmfile)  
  1138. if( curseg != dataseg) {
  1139.                 nl();
  1140.                 fprintf(outputFile,"tSECTIONtdatan");
  1141.                 curseg = dataseg;
  1142.                 }
  1143. }
  1144. /*
  1145.  * Switch to bssseg
  1146.  */
  1147. void bssseg(void)
  1148. {     if (prm_asmfile)  
  1149. if( curseg != bssxseg) {
  1150.                 nl();
  1151.                 fprintf(outputFile,"tSECTIONtbssn");
  1152.                 curseg = bssxseg;
  1153.                 }
  1154. }
  1155. /*
  1156.  * Switch to startupseg
  1157.  */
  1158. void startupseg(void)
  1159. {     if (prm_asmfile)  
  1160. if( curseg != startupxseg) {
  1161.                 nl();
  1162.                 fprintf(outputFile,"tSECTIONtcstartupn");
  1163.                 curseg = startupxseg;
  1164.                 }
  1165. }
  1166. /*
  1167.  * Switch to rundownseg
  1168.  */
  1169. void rundownseg(void)
  1170. {     if (prm_asmfile)  
  1171. if( curseg != rundownxseg) {
  1172.                 nl();
  1173.                 fprintf(outputFile,"tSECTIONtcrundownn");
  1174.                 curseg = rundownxseg;
  1175.                 }
  1176. }
  1177. /*
  1178.  * Switch to cppseg
  1179.  */
  1180. void cppseg(void)
  1181. {     if (prm_asmfile)  
  1182. if( curseg != cppxseg) {
  1183.                 nl();
  1184.                 fprintf(outputFile,"tSECTIONtcppinitn");
  1185.                 curseg = cppxseg;
  1186.                 }
  1187. }
  1188. void gen_virtual(char *name)
  1189. /*
  1190.  * Generate a virtual segment
  1191.  */
  1192. {
  1193. if (prm_asmfile) {
  1194. nl();
  1195. fprintf(outputFile,"@%stVIRTUAL",name);
  1196. }
  1197. }
  1198. void gen_endvirtual(char *name)
  1199. /*
  1200.  * Generate the end of a virtual segment
  1201.  */
  1202. {
  1203. if (prm_asmfile) {
  1204. nl();
  1205. fprintf(outputFile,"@%stENDVIRTUAL",name);
  1206. }
  1207. }
  1208. void genlongref(DATALINK *p)
  1209. /*
  1210.  * Generate a reference reference for fixup tables
  1211.  */
  1212. {
  1213. if (prm_asmfile) 
  1214.         if( gentype == longgen && outcol < 56) {
  1215.                 fprintf(outputFile,",%s+$%X",p->sp->name,p->offset);
  1216.                 outcol += 10;
  1217.                 }
  1218.         else    {
  1219.                 nl();
  1220.                 fprintf(outputFile,"tDC.Lt%s+$%X",p->sp->name,p->offset);
  1221.                 gentype = longgen;
  1222.                 outcol = 25;
  1223.                 }
  1224. else
  1225. ;/* oc_longen(p->sp,p->offset); */
  1226. }
  1227. /*
  1228.  * Assembly file header
  1229.  */
  1230. void asm_header(void)
  1231. {
  1232. }
  1233. void globaldef(SYM *sp)
  1234. /*
  1235.  * Stick in a global definition
  1236.  */
  1237. {
  1238. if (prm_asmfile) {
  1239. char buf[100],*q=buf,*p=sp->name;
  1240. nl();
  1241. if (curseg == codeseg && sp->pascaldefn) {
  1242. if (prm_cmangle)
  1243. p++;
  1244. while(*p)
  1245. *q++=toupper(*p++);
  1246. *q++ = 0;
  1247. }
  1248. else
  1249. strcpy(buf,p);
  1250.     fprintf(outputFile,"tXDEFt%sn",buf);
  1251. }
  1252. }
  1253. void putexterns(void)
  1254. /*
  1255.  * Output the fixup tables and the global/external list
  1256.  */
  1257. {       SYM     *sp;
  1258. DATALINK *p;
  1259. int i;
  1260. int started = FALSE;
  1261. p = datahead;
  1262. curseg = fixcseg;
  1263. while (p) {
  1264. if (p->type) {
  1265. if (!started && prm_asmfile) {
  1266.                 nl();
  1267.                 fprintf(outputFile,"tSECTIONtcodefixn");
  1268. started = TRUE;
  1269. }
  1270. genlongref(p);
  1271. }
  1272. p = p->next;
  1273. }
  1274. started = FALSE;
  1275. p = datahead;
  1276. curseg = fixdseg;
  1277. while (p) {
  1278. if (!p->type) {
  1279. if (!started && prm_asmfile) {
  1280.                 nl();
  1281.                 fprintf(outputFile,"tSECTIONtdatafixn");
  1282. started = TRUE;
  1283. }
  1284. genlongref(p);
  1285. }
  1286. p = p->next;
  1287. }
  1288. curseg = noseg;
  1289. if (prm_asmfile) {
  1290. nl();
  1291. for (i=0; i < HASHTABLESIZE; i++) {
  1292. if ((sp=(SYM *) globalhash[i]) != 0) {
  1293. while (sp) {
  1294.         if( (sp->storage_class == sc_external  || sp->storage_class == sc_externalfunc)&& sp->extflag) {
  1295. char buf[100],*q=buf,*p=sp->name;
  1296. if (curseg == codeseg && sp->pascaldefn) {
  1297. if (prm_cmangle)
  1298. p++;
  1299. while(*p)
  1300. *q++=toupper(*p++);
  1301. *q++ = 0;
  1302. }
  1303. else
  1304. strcpy(buf,p);
  1305.                fprintf(outputFile,"tXREFt%sn",buf);
  1306. }
  1307.          sp = sp->next;
  1308. }
  1309. }
  1310. }
  1311. }
  1312. else
  1313. ;/* oc_gencode(); */
  1314. }