开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
OUTAS386.C
资源名称：c_compiler.zip　[点击查看]
上传用户：hlzzc88
上传日期：2007-01-06
资源大小：220k
文件大小：33k
源码类别：

编译器/解释器

开发平台：

Others

OUTAS386.C：源码内容
  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        "gen386.h"
  27. #include  "diag.h"
  29. int skipsize = 0;
  30. int addsize = 0;
  32. typedef struct muldiv {
  33. struct muldiv * link;
  34. long value;
  35. double floatvalue;
  36. int size;
  37. int label;
  38. } MULDIV;
  39. /*      variable initialization         */
  41. char segregs[] = "CSDSESFSGSSS";
  43. extern char outfile[];
  44. extern int prm_flat;
  45. extern SYM *currentfunc;
  46. extern int prm_cmangle;
  47. extern HASHREC **globalhash;
  48. extern int phiused;
  49. extern long nextlabel;
  50. extern FILE *outputFile;
  51. extern int global_flag;
  53. enum e_gt { nogen, bytegen, wordgen, longgen, floatgen, doublegen, longdoublegen, storagegen,srrefgen };
  54. enum e_sg { noseg, codeseg, dataseg,bssxseg,startupxseg,rundownxseg,cppxseg };
  56. extern int prm_asmfile;
  57. extern int prm_lines,prm_nasm;
  59. static struct slit *strtab;
  60. static int uses_float;
  62. MULDIV *muldivlink = 0;
  63. enum e_gt  gentype = nogen; /* Current DC type */
  64. enum e_sg  curseg = noseg; /* Current seg */
  65. int        outcol = 0; /* Curront col (roughly) */
  66. int newlabel;
  67. int needpointer;
  68. static int nosize = 0;
  69. static int phiput;
  71. /* List of opcodes
  72.  * This list MUST be in the same order as the op_ enums 
  73.  */
  74. ASMNAME oplst[] = { 
  75. { "reserved", op_reserved,0 },
  76. { "line#", op_reserved,0 },
  77. { "label", op_reserved,0 },
  78. { "flabel", op_reserved,0 },
  79. { "seq@", op_reserved,0 },
  80. { "db", op_reserved,0 },
  81. { "dd", op_reserved,0 },
  82. { "aaa", op_aaa,0 },
  83. { "aad", op_aad,0 },
  84. { "aam", op_aam,0 },
  85. { "aas", op_aas,0 },
  86. { "add", op_add,OPE_MATH },
  87. { "adc", op_adc,OPE_MATH },
  88. { "and", op_and,OPE_MATH },
  89. { "arpl", op_arpl,OPE_ARPL },
  90. { "bound", op_bound,OPE_BOUND },
  91. { "bsf", op_bsf,OPE_BITSCAN },
  92. { "bsr", op_bsr,OPE_BITSCAN },
  93. { "bswap",op_bswap,OPE_REG32 },
  94. { "btc", op_btc,OPE_BIT },
  95. { "bt", op_bt,OPE_BIT },
  96. { "bts", op_bts,OPE_BIT },
  97. { "call", op_call,OPE_CALL },
  98. { "cbw", op_cbw,0 },
  99. { "cwde", op_cwde,0 },
  100. { "cwd", op_cwd, 0 },
  101. { "cdq", op_cdq,0 },
  102. { "clc", op_clc,0 },
  103. { "cld", op_cld,0 },
  104. { "cli", op_cli,0 },
  105. { "clts", op_clts, 0 },
  106. { "cmc", op_cmc, 0 },
  107. { "cmp", op_cmp, OPE_MATH },
  108. { "cmps", op_cmps, OPE_CMPS },
  109. { "cmpsb", op_cmpsb, 0 },
  110. { "cmpsw", op_cmpsw, 0 },
  111. { "cmpsd", op_cmpsd, 0 },
  112. { "daa",op_daa,0 },
  113. { "das", op_das,0 },
  114. { "dec",op_dec, OPE_INCDEC},
  115. { "div", op_div, OPE_RM},
  116. { "enter", op_enter, OPE_ENTER},
  117. { "hlt", op_hlt, 0 },
  118. { "idiv", op_idiv, OPE_RM },
  119. { "imul", op_imul, OPE_IMUL },
  120. { "in", op_in, OPE_IN },
  121. { "inc", op_inc, OPE_INCDEC },
  122. { "ins", op_ins, OPE_INS },
  123. { "insb", op_insb, 0 },
  124. { "insw", op_insw, 0 },
  125. { "insd", op_insd, 0 },
  126. { "int" , op_int, OPE_IMM8 },
  127. { "into", op_into, 0 },
  128. { "invd", op_invd, 0 },
  129. { "iret", op_iret, 0},
  130. { "iretd", op_iretd, 0},
  131. { "ja", op_ja, OPE_RELBRA},
  132. { "jnbe", op_jnbe, OPE_RELBRA},
  133. { "jae", op_jae, OPE_RELBRA},
  134. { "jnb", op_jnb, OPE_RELBRA},
  135. { "jnc", op_jnc, OPE_RELBRA},
  136. { "jb", op_jb, OPE_RELBRA},
  137. { "jc", op_jc, OPE_RELBRA},
  138. { "jnae", op_jnae, OPE_RELBRA},
  139. { "jbe", op_jbe, OPE_RELBRA},
  140. { "jna", op_jna, OPE_RELBRA},
  141. { "jecxz", op_jecxz, OPE_RELBR8},
  142. { "je",op_je, OPE_RELBRA },
  143. { "jg",op_jg, OPE_RELBRA },
  144. { "jnle",op_jnle, OPE_RELBRA },
  145. { "jl",op_jl, OPE_RELBRA },
  146. { "jnge",op_jnge, OPE_RELBRA },
  147. { "jge", op_jge, OPE_RELBRA },
  148. { "jnl", op_jnl, OPE_RELBRA },
  149. { "jle", op_jle, OPE_RELBRA },
  150. { "jng", op_jng, OPE_RELBRA },
  151. { "jne", op_jne, OPE_RELBRA },
  152. { "jo", op_jo, OPE_RELBRA },
  153. { "jno", op_jno, OPE_RELBRA },
  154. { "jp", op_jp, OPE_RELBRA },
  155. { "jpe", op_jpe, OPE_RELBRA },
  156. { "jpo", op_jpo, OPE_RELBRA },
  157. { "js", op_js, OPE_RELBRA} ,
  158. { "jns", op_jns, OPE_RELBRA },
  159. { "jmp", op_jmp, OPE_JMP },
  160. { "lahf", op_lahf, 0 },
  161. { "lar", op_lar, OPE_REGRM },
  162. { "lds", op_lds, OPE_LOADSEG },
  163. { "les", op_les, OPE_LOADSEG },
  164. { "lfs", op_lfs, OPE_LOADSEG },
  165. { "lgs", op_lgs, OPE_LOADSEG },
  166. { "lss", op_lss, OPE_LOADSEG },
  167. { "lea", op_lea, OPE_REGRM },
  168. { "leave", op_leave, 0 },
  169. { "lgdt", op_lgdt, OPE_LGDT },
  170. { "lidt", op_lidt, OPE_LIDT },
  171. { "lldt", op_lldt, OPE_RM16 },
  172. { "lmsw", op_lmsw, OPE_RM16 },
  173. { "lock", op_lock, 0 },
  174. { "lods", op_lods, OPE_LODS },
  175. { "lodsb", op_lodsb, 0 },
  176. { "lodsw", op_lodsw, 0 },
  177. { "lodsd", op_lodsd, 0 },
  178. { "loop",op_loop, OPE_RELBR8 },
  179. { "loope",op_loope, OPE_RELBR8 },
  180. { "loopz",op_loopz, OPE_RELBR8 },
  181. { "loopne",op_loopne, OPE_RELBR8 },
  182. { "loopnz",op_loopnz, OPE_RELBR8 },
  183. { "lsl", op_lsl, OPE_REGRM },
  184. { "ltr", op_ltr, OPE_RM16 },
  185. { "mov", op_mov, OPE_MOV },
  186. { "movs", op_movs, OPE_MOVS },
  187. { "movsb", op_movsb, 0 },
  188. { "movsw", op_movsw, 0 },
  189. { "movsd", op_movsd, 0 },
  190. { "movsx", op_movsx, OPE_MOVSX} ,
  191. { "movzx", op_movzx, OPE_MOVSX} ,
  192. { "mul", op_mul, OPE_RM },
  193. { "neg", op_neg, OPE_RM },
  194. { "not", op_not, OPE_RM },
  195. { "nop", op_nop, 0 },
  196. { "or", op_or,OPE_MATH },
  197. { "out", op_out,OPE_OUT },
  198. { "outs", op_outs, OPE_OUTS },
  199. { "outsb", op_outsb, 0 },
  200. { "outsw", op_outsw, 0 },
  201. { "outsd", op_outsd, 0 },
  202. { "pop",op_pop, OPE_PUSHPOP },
  203. { "popa", op_popa, 0 },
  204. { "popad", op_popad, 0 },
  205. { "popf", op_popf, 0 },
  206. { "popfd", op_popfd, 0 },
  207. { "push",op_push, OPE_PUSHPOP },
  208. { "pusha", op_pusha, 0 },
  209. { "pushad", op_pushad, 0 },
  210. { "pushf", op_pushf, 0 },
  211. { "pushfd", op_pushfd, 0 },
  212. { "rcl", op_rcl, OPE_SHIFT },
  213. { "rcr", op_rcr, OPE_SHIFT },
  214. { "rol", op_rol, OPE_SHIFT },
  215. { "ror", op_ror, OPE_SHIFT },
  216. { "rep", op_rep, 0 },
  217. { "repne", op_repne, 0 },
  218. { "repe", op_repe, 0 },
  219. { "repnz", op_repnz, 0 },
  220. { "repz", op_repz, 0 },
  221. { "ret", op_ret, OPE_RET },
  222. { "sahf", op_sahf, 0 },
  223. { "sal", op_sal, OPE_SHIFT },
  224. { "sar", op_sar, OPE_SHIFT },
  225. { "shl", op_shl, OPE_SHIFT },
  226. { "shr", op_shr, OPE_SHIFT },
  227. { "sbb", op_sbb,OPE_MATH },
  228. { "scas", op_scas, OPE_SCAS },
  229. { "scasb", op_scasb, 0 },
  230. { "scasw", op_scasw, 0 },
  231. { "scasd", op_scasd, 0 },
  232. { "seta", op_seta, OPE_SET},
  233. { "setnbe", op_setnbe, OPE_SET},
  234. { "setae", op_setae, OPE_SET},
  235. { "setnb", op_setnb, OPE_SET},
  236. { "setnc", op_setnc, OPE_SET},
  237. { "setb", op_setb, OPE_SET},
  238. { "setc", op_setc, OPE_SET},
  239. { "setnae", op_setnae, OPE_SET},
  240. { "setbe", op_setbe, OPE_SET},
  241. { "setna", op_setna, OPE_SET},
  242. { "sete",op_sete, OPE_SET },
  243. { "setg",op_setg, OPE_SET },
  244. { "setnle",op_setnle, OPE_SET },
  245. { "setl",op_setl, OPE_SET },
  246. { "setnge",op_setnge, OPE_SET },
  247. { "setge", op_setge, OPE_SET },
  248. { "setnl", op_setnl, OPE_SET },
  249. { "setle", op_setle, OPE_SET },
  250. { "setng", op_setng, OPE_SET },
  251. { "setne", op_setne, OPE_SET },
  252. { "seto", op_seto, OPE_SET },
  253. { "setno", op_setno, OPE_SET },
  254. { "setp", op_setp, OPE_SET },
  255. { "setpe", op_setpe, OPE_SET },
  256. { "setpo", op_setpo, OPE_SET },
  257. { "sets", op_sets, OPE_SET} ,
  258. { "setns", op_setns, OPE_SET },
  259. { "sgdt", op_sgdt, OPE_LGDT },
  260. { "sidt", op_sidt, OPE_LIDT },
  261. { "sldt", op_sldt, OPE_RM16 },
  262. { "smsw", op_smsw, OPE_RM16 },
  263. { "shld", op_shld, OPE_SHLD },
  264. { "shrd", op_shrd, OPE_SHLD },
  265. { "stc", op_stc, 0 },
  266. { "std", op_std, 0 },
  267. { "sti", op_sti, 0 },
  268. { "stos", op_stos, OPE_STOS },
  269. { "stosb", op_stosb, 0 },
  270. { "stosw", op_stosw, 0 },
  271. { "stosd", op_stosd, 0 },
  272. { "str", op_str, OPE_RM16 },
  273. { "sub", op_sub, OPE_MATH },
  274. { "test", op_test, OPE_TEST },
  275. { "verr", op_verr, OPE_RM16 },
  276. { "verw", op_verw, OPE_RM16 },
  277. { "wait", op_wait, 0 },
  278. { "wbinvd", op_wbinvd, 0 },
  279. { "xchg", op_xchg, OPE_XCHG },
  280. { "xlat", op_xlat, OPE_XLAT },
  281. { "xlatb", op_xlatb, 0 },
  282. { "xor", op_xor,OPE_MATH },
  283. { "f2xm1", op_f2xm1, 0 },
  284. { "fabs", op_fabs, 0 },
  285. { "fadd", op_fadd, OPE_FMATH },
  286. { "faddp", op_faddp, OPE_FMATHP },
  287. { "fiadd", op_fiadd, OPE_FMATHI },
  288. { "fchs", op_fchs, 0 },
  289. { "fclex", op_fclex, 0 },
  290. { "fnclex", op_fnclex, 0 },
  291. { "fcom", op_fcom, OPE_FCOM },
  292. { "fcomp", op_fcomp, OPE_FCOM },
  293. { "fcompp", op_fcompp, 0 },
  294. { "fcos", op_fcos, 0 },
  295. { "fdecstp", op_fdecstp, 0 },
  296. { "fdiv", op_fdiv, OPE_FMATH },
  297. { "fdivp", op_fdivp, OPE_FMATHP },
  298. { "fidiv", op_fidiv, OPE_FMATHI },
  299. { "fdivr", op_fdivr, OPE_FMATH },
  300. { "fdivrp", op_fdivrp, OPE_FMATHP },
  301. { "fidivr", op_fidivr, OPE_FMATHI },
  302. { "ffree", op_ffre, OPE_FREG },
  303. { "ficom", op_ficom, OPE_FICOM },
  304. { "ficomp", op_ficomp, OPE_FICOM },
  305. { "fild", op_fild, OPE_FILD },
  306. { "fincstp", op_fincstp, 0 },
  307. { "finit", op_finit, 0 },
  308. { "fninit", op_fninit, 0 },
  309. { "fist", op_fist, OPE_FIST },
  310. { "fistp", op_fistp, OPE_FILD },
  311. { "fld", op_fld, OPE_FLD },
  312. { "fldz", op_fldz, 0},
  313. { "fldpi", op_fldpi, 0},
  314. { "fld1", op_fld1, 0},
  315. { "fldl2t", op_fld2t, 0},
  316. { "fldl2e", op_fld2e, 0},
  317. { "fldlg2", op_fldlg2, 0},
  318. { "fldln2", op_fldln2, 0},
  319. { "fldcw", op_fldcw, OPE_M16 },
  320. { "fldsw", op_fldsw, OPE_M16 },
  321. { "fldenv", op_fldenv, OPE_MN },
  322. { "fmul", op_fmul, OPE_FMATH},
  323. { "fmulp", op_fmulp, OPE_FMATHP},
  324. { "fimul", op_fimul, OPE_FMATHI },
  325. { "fpatan", op_fpatan, 0 },
  326. { "fprem", op_fprem, 0 },
  327. { "fprem1", op_fprem1, 0 },
  328. { "fptan", op_fptan, 0 },
  329. { "frndint", op_frndint, 0 },
  330. { "frstor", op_frstor, OPE_MN },
  331. { "fsave", op_fsave, OPE_MN },
  332. { "fnsave", op_fnsave, OPE_MN },
  333. { "fscale", op_fscale, 0 },
  334. { "fsin", op_fsin, 0 },
  335. { "fsincos", op_fsincos, 0 },
  336. { "fsqrt", op_fsqrt, 0 },
  337. { "fst", op_fst, OPE_FST},
  338. { "fstp", op_fstp, OPE_FSTP},
  339. { "fstcw", op_fstcw, OPE_M16},
  340. { "fstsw", op_fstsw, OPE_M16},
  341. { "fnstcw", op_fnstcw, OPE_M16},
  342. { "fnstsw", op_fnstsw, OPE_M16},
  343. { "fstenv", op_fstenv, OPE_MN },
  344. { "fnstenv", op_fsntenv, OPE_MN },
  345. { "fsub", op_fsub, OPE_FMATH},
  346. { "fsubp", op_fsubp, OPE_FMATHP},
  347. { "fisub", op_fisub, OPE_FMATHI},
  348. { "fsubr", op_fsubr, OPE_FMATH},
  349. { "fsubrp", op_fsubrp, OPE_FMATHP},
  350. { "fisubr", op_fisubr, OPE_FMATHI},
  351. { "ftst", op_ftst, 0},
  352. { "fucom", op_fucom, OPE_FUCOM },
  353. { "fucomp", op_fucomp, OPE_FUCOM },
  354. { "fucompp", op_fucompp, 0 },
  355. { "fwait", op_fwait, 0 },
  356. { "fxam", op_fxam, 0 },
  357. { "fxch", op_fxch, OPE_FXCH },
  358. { "fxtract", op_fxtract, 0 },
  359. { "fyl2x", op_fyl2x, 0 },
  360. { "fyl2xp1", op_fyl2xp1, 0 },
  361. {0,0,0 },
  362. };
  363. /* Init module */
  364. void outcodeini(void)
  365. {
  366. strtab = 0;
  367. gentype = nogen;
  368. curseg = noseg;
  369. outcol = 0;
  370. newlabel = FALSE;
  371. phiput = FALSE;
  372. }
  373. void nl(void)
  374. /*
  375.  * New line
  376.  */
  377. {    if (prm_asmfile) {
  378.        if(outcol > 0) {
  379.                 fputc('n',outputFile);
  380.                 outcol = 0;
  381.                 gentype = nogen;
  382.                 }
  383.  if (phiused && !phiput)
  384. fputc(0x1f,outputFile);
  385.  }
  386. }
  387. /* Put an opcode
  388.  */
  389. void outop(char *name)
  390. {
  391. fputc('t',outputFile);
  392. while (*name)
  393. fputc(toupper(*name++),outputFile);
  394. }
  395. void putop(enum e_op op)
  396. {    
  397. if (prm_nasm) {   
  398.    skipsize =  (op == op_lea);
  399.    addsize = (op == op_push);
  400. if (op == op_fwait) {
  401. /* NASM uses WAIT instead of FWAIT */
  402. outop(oplst[op_fwait].word+1);
  403. return;
  404. }
  405. }
  406. if (op > op_fyl2xp1)
  407.     DIAG("illegal opcode.");
  408. else
  409. outop(oplst[op].word);
  410. uses_float=(op >=op_f2xm1);
  411. }
  413. void putconst(ENODE *offset)
  414. /*
  415.  *      put a constant to the outputFile file.
  416.  */
  417. {       switch( offset->nodetype )
  418.                 {
  419. case en_autoreg:
  420.                 case en_autocon:
  421.                 case en_icon:
  422.                 case en_lcon:
  423.                 case en_iucon:
  424.                 case en_lucon:
  425.                 case en_ccon:
  426. case en_absacon:
  427.                         fprintf(outputFile,"0%lXH",offset->v.i);
  428.                         break;
  429. case en_rcon:
  430. case en_fcon:
  431. case en_lrcon:
  432. fprintf(outputFile,"%f",offset->v.f);
  433. break;
  434.                 case en_labcon:
  435.                 case en_nalabcon:
  436. /* if (!prm_nasm && !prm_flat)
  437. fprintf(outputFile,"CS:");
  438. */                        fprintf(outputFile,"L_%d",offset->v.i);
  439.                         break;
  440. case en_napccon:
  441.                 case en_nacon:
  442.                         fprintf(outputFile,"%s",offset->v.p[0]);
  443.                         break;
  444.                 case en_add:
  445.                         putconst(offset->v.p[0]);
  446.                         fprintf(outputFile,"+");
  447.                         putconst(offset->v.p[1]);
  448.                         break;
  449.                 case en_sub:
  450.                         putconst(offset->v.p[0]);
  451.                         fprintf(outputFile,"-");
  452.                         putconst(offset->v.p[1]);
  453.                         break;
  454.                 case en_uminus:
  455.                         fprintf(outputFile,"-");
  456.                         putconst(offset->v.p[0]);
  457.                         break;
  458.                 default:
  459.                         DIAG("illegal constant node.");
  460.                         break;
  461.                 }
  462. }
  463. void putlen(int l)
  464. /*
  465.  *      append the length field to an instruction.
  466.  */
  467. { 
  468. if (l!= 10 && l != 8 && l != 6 && l != 4 && l != 1 && l != 2 && l != 0)
  469.      DIAG("illegal length field.");
  470. }
  471. void putsizedreg(char *string, int reg, int size)
  472. {
  473. static char *byteregs[] = { "AL","CL","DL","BL","AH","CH","DH","BH" };
  474. static char *wordregs[] = { "AX", "CX", "DX","BX","SP","BP","SI","DI"  };
  475. static char *longregs[] = { "EAX", "ECX", "EDX","EBX","ESP","EBP","ESI","EDI" };
  476.   if (size == 4)
  477. fprintf(outputFile,string,longregs[reg]);
  478. else if (size == 1)
  479. fprintf(outputFile,string,byteregs[reg]);
  480. else
  481. fprintf(outputFile,string,wordregs[reg]);
  482. }
  483. void pointersize(int size)
  484. {
  485. if (prm_nasm && skipsize)
  486. return;
  487. /* if (needpointer)
  488. */ switch (size) {
  489. case 10:
  490. fprintf(outputFile,"TBYTE ");
  491. break;
  492. case 8:                      
  493.         fprintf(outputFile,"QWORD ");
  494. break;
  495. case 6:
  496. if (!uses_float) {
  497. fprintf(outputFile,"FWORD ");
  498. break;
  499. }
  500. case 4:                      
  501. fprintf(outputFile,"DWORD ");
  502. break;
  503. case 2:
  504. fprintf(outputFile,"WORD ");
  505. break;
  506. case 1:
  507. fprintf(outputFile,"BYTE ");
  508. break;
  509. default:
  510. DIAG("Bad pointer");
  511. }
  512. if (!prm_nasm)
  513. fprintf(outputFile,"PTR ");
  514. }
  515. void putseg(int seg, int usecolon)
  516. {
  517. if (!seg)
  518. return;
  519. seg-=1;
  520. seg<<=1;
  521. fputc(segregs[seg], outputFile);
  522. fputc(segregs[seg+1], outputFile);
  523.   if (usecolon)
  524. fputc(':', outputFile);
  525. }
  527. void putamode(AMODE *ap)
  528. /*
  529.  *      output a general addressing mode.
  530.  */
  532. { int oldnasm, l;
  533.        switch( ap->mode )
  534.                 {
  535. case am_seg:
  536. putseg(ap->seg,0);
  537. break;
  538. case am_screg:
  539. fprintf(outputFile,"CR%d",ap->preg);
  540. break;
  541. case am_sdreg:
  542. fprintf(outputFile,"DR%d",ap->preg);
  543. break;
  544. case am_streg:
  545. fprintf(outputFile,"TR%d",ap->preg);
  546. break;
  547.                 case am_immed:
  548. if (ap->length && (ap->offset->nodetype == en_labcon 
  549. || ap->offset->nodetype == en_nacon || ap->offset->nodetype == en_nalabcon
  550. || ap->offset->nodetype == en_napccon)) {
  551. if (!prm_nasm)
  552. fprintf(outputFile,"OFFSET ");
  553.   else
  554. if (!nosize) 
  555. fprintf(outputFile,"DWORD ");
  556. }
  557. else
  558. if (prm_nasm && addsize)
  559. pointersize(ap->length);
  560.                         putconst(ap->offset);
  561. break;
  562.                 case am_direct:
  563. pointersize(ap->length);
  564. putseg(ap->seg,TRUE);
  565. /* if (!prm_flat)
  566. fprintf(outputFile,"DS:");
  567. */ fprintf(outputFile,"[");
  568. oldnasm = prm_nasm;
  569. prm_nasm = TRUE;
  570.                         putconst(ap->offset);
  571. fputc(']',outputFile);
  572. prm_nasm = oldnasm;
  573.                         break;
  574.                 case am_dreg:
  575. putsizedreg("%s",ap->preg,ap->length);
  576. break;
  577. case am_freg:
  578. fprintf(outputFile,"ST(%d)",ap->preg);
  579. break;
  580. case am_indisp:
  581. pointersize(ap->length);
  582. putseg(ap->seg,TRUE);
  583. putsizedreg("[%s",ap->preg,4);
  584. if (ap->offset) {
  585. fputc('+',outputFile);
  586. putconst(ap->offset);
  587. }
  588. fputc(']',outputFile);
  589. break;
  590. case am_indispscale: {
  591. int scale = 1,t=ap->scale;
  592. while (t--)
  593. scale <<=1;
  594. pointersize(ap->length);
  595. putseg(ap->seg,TRUE);
  596. if (ap->preg == -1)
  597. fputc('[',outputFile);
  598. else
  599. putsizedreg("[%s+",ap->preg,4);
  600. putsizedreg("%s",ap->sreg,4);
  601. if (scale != 1)
  602. fprintf(outputFile,"*%d",scale);
  603. if (ap->offset) {
  604. fputc('+',outputFile);
  605. putconst(ap->offset);
  606. }
  607. fputc(']',outputFile);
  608. }
  609. break;
  610.                 default:
  611.                         DIAG("illegal address mode.");
  612.                         break;
  613.                 }
  614. }
  616. void put_code(OCODE *cd)
  617. /*
  618.  *      outputFile a generic instruction.
  619.  */
  620. {       
  621. int op = cd->opcode,len=0,len2=0;
  622. AMODE *aps = cd->oper1,*apd = cd->oper2, *ap3 = cd->oper3;
  623. if (!prm_asmfile)
  624. return;
  625. if (op == op_line) {
  626. if (!prm_lines)
  627. return;
  628. fprintf(outputFile,";n; Line %d:t%sn;n",(int)apd,(char *)aps);
  629. return;
  630. }
  631. if (aps)
  632. len = aps->length;
  633. if (apd)
  634. len2 = apd->length;
  635. needpointer = (len != len2) || ((!aps || aps->mode !=am_dreg) && (!apd || apd->mode !=am_dreg));
  636. putop(op);
  637. if (prm_nasm && op >=op_ja && op <= op_jns)
  638. fprintf(outputFile,"tNEAR");
  639. switch (op) {
  640. case op_rep:
  641. case op_repz:
  642. case op_repe:
  643. case op_repnz:
  644. case op_repne:
  645. case op_lock:
  646. return;
  647. }
  648.     putlen(len);
  649.         if( aps != 0 ) {
  650.                 fprintf(outputFile,"t");
  651. if (op == op_dd)
  652. nosize = TRUE;
  653. putamode(aps);
  654. nosize = FALSE;
  655.                 if( apd != 0 ) 
  656.                         {
  657.                         fprintf(outputFile,",");
  658.                         putamode(apd);
  659.                         }
  660.                 if( ap3 != 0 ) 
  661.                         {
  662.                         fprintf(outputFile,",");
  663.                         putamode(ap3);
  664.                         }
  665. }
  666.   fprintf(outputFile,"n");
  667. }
  669. void gen_strlab(SYM *s)
  670. /*
  671.  *      generate a named label.
  672.  */
  673. {
  674. if (prm_asmfile)
  675. if (curseg == dataseg || curseg == bssxseg) {
  676. newlabel = TRUE;
  677.   fprintf(outputFile,"n%s",s->name);
  678. outcol = strlen(s->name)+1;
  679. }
  680. else
  681. if (currentfunc->pascaldefn) {
  682. char buf[100],*q=buf,*p=s->name;
  683. if (prm_cmangle)
  684. p++;
  685. while(*p)
  686. *q++=toupper(*p++);
  687. *q++ = 0;
  688.          fprintf(outputFile,"%s:n",buf);
  689. }
  690. else
  691.          fprintf(outputFile,"%s:n",s->name);
  692. }
  694. void put_label(int lab)
  695. /*
  696.  *      outputFile a compiler generated label.
  697.  */
  698. {
  699.        if (prm_asmfile)
  700. fprintf(outputFile,"L_%d:n",lab);
  701. }
  702. void put_staticlabel(long label)
  703. {
  704. if (prm_asmfile) {
  705. nl();
  706. if (curseg == dataseg || curseg == bssxseg) {
  707. newlabel = TRUE;
  708.   fprintf(outputFile,"nL_%ld",label);
  709. outcol = 8;
  710. }
  711. else
  712. fprintf(outputFile,"L_%ld:n",label);
  713. }
  714. }
  716. void genfloat(float val)
  717. /*
  718.  * Output a float value
  719.  */
  720. {  if (prm_asmfile)
  721.         if( gentype == floatgen && outcol < 60) {
  722.                 fprintf(outputFile,",%f",val);
  723.                 outcol += 8;
  724.                 }
  725.         else    {
  726. if (!newlabel)
  727. nl();
  728. else newlabel = FALSE;
  729.                 fprintf(outputFile,"tDDt%f",val);
  730.                 gentype = floatgen;
  731.                 outcol = 19;
  732.                 }
  733. }
  735. void gendouble(double val)
  736. /*
  737.  * Output a double value
  738.  */
  739. {  if (prm_asmfile)
  740.         if( gentype == doublegen && outcol < 60) {
  741.                 fprintf(outputFile,",%f",val);
  742.                 outcol += 8;
  743.                 }
  744.         else    {
  745. if (!newlabel)
  746. nl();
  747. else newlabel = FALSE;
  748.                 fprintf(outputFile,"tDQt%f",val);
  749.                 gentype = doublegen;
  750.                 outcol = 19;
  751.                 }
  752. }
  753. void genlongdouble(double val)
  754. /*
  755.  * Output a double value
  756.  */
  757. {  if (prm_asmfile)
  758.         if( gentype == longdoublegen && outcol < 60) {
  759.                 fprintf(outputFile,",%f",val);
  760.                 outcol += 8;
  761.                 }
  762.         else    {
  763. if (!newlabel)
  764. nl();
  765. else newlabel = FALSE;
  766.                 fprintf(outputFile,"tDTt%f",val);
  767.                 gentype = longdoublegen;
  768.                 outcol = 19;
  769.                 }
  770. }
  771. int genstring(char *str, int uselong)
  772. /*
  773.  * Generate a string literal
  774.  */
  775. {
  776. if (uselong) {
  777. while  (*(short *)str) {
  778. genword(*((short *)str));
  779. str+=2;
  780. }
  781. return pstrlen(str)*2;
  782. }
  783. else {
  784. while (*str)
  785. genbyte(*str++);
  786. return strlen(str);
  787. }
  788. }
  789. void genbyte(long val)
  790. /*
  791.  * Output a byte value
  792.  */
  793. {  if (prm_asmfile)
  794.         if( gentype == bytegen && outcol < 60) {
  795.                 fprintf(outputFile,",0%XH",val & 0x00ff);
  796.                 outcol += 4;
  797.                 }
  798.         else    {
  799. if (!newlabel)
  800. nl();
  801. else newlabel = FALSE;
  802.                 fprintf(outputFile,"tDBt0%XH",val & 0x00ff);
  803.                 gentype = bytegen;
  804.                 outcol = 19;
  805.                 }
  806. }
  808. void genword(long val)
  809. /*
  810.  * Output a word value
  811.  */
  812. {     if (prm_asmfile)
  813.         if( gentype == wordgen && outcol < 58) {
  814.                 fprintf(outputFile,",0%XH",val & 0x0ffff);
  815.                 outcol += 6;
  816.                 }
  817.         else    {
  818. if (!newlabel)
  819. nl();
  820. else newlabel = FALSE;
  821.                 fprintf(outputFile,"tDWt0%XH",val & 0x0ffff);
  822.                 gentype = wordgen;
  823.                 outcol = 21;
  824.                 }
  825. }
  827. void genlong(long val)
  828. /*
  829.  * Output a long value
  830.  */
  831. {     if (prm_asmfile)
  832.         if( gentype == longgen && outcol < 56) {
  833.                 fprintf(outputFile,",0%lXH",val);
  834.                 outcol += 10;
  835.                 }
  836.         else    {
  837. if (!newlabel)
  838. nl();
  839. else newlabel = FALSE;
  840.                 fprintf(outputFile,"tDDt0%lXH",val);
  841.                 gentype = longgen;
  842.                 outcol = 25;
  843.                 }
  844. }
  846. void gensrref(SYM *sp, int val)
  847. {
  848. if (prm_asmfile)
  849.         if( gentype == srrefgen && outcol < 56) {
  850.                 fprintf(outputFile,",%s,%d",sp->name,val);
  851.                 outcol += strlen(sp->name)+1;
  852.                 }
  853.         else    {
  854.                 nl();
  855.                 fprintf(outputFile,"tDDt%s,%d",sp->name,val);
  856.                 gentype = srrefgen;
  857.                 outcol = 25;
  858.                 }
  859. }
  860. void genref(SYM *sp,int offset)
  861. /*
  862.  * Output a reference to the data area (also gens fixups )
  863.  */
  864. {       char    sign;
  865. char buf[40];
  866.         if( offset < 0) {
  867.                 sign = '-';
  868.                 offset = -offset;
  869.                 }
  870.         else
  871.                 sign = '+';
  872. sprintf(buf,"%s%c%d",sp->name,sign,offset);
  873. if (prm_asmfile) {
  874.         if( gentype == longgen && outcol < 55 - strlen(sp->name)) {
  875.                 fprintf(outputFile,",%s",buf);
  876.                 outcol += (11 + strlen(sp->name));
  877.                 }
  878.         else    {
  879. if (!newlabel)
  880. nl();
  881. else newlabel = FALSE;
  882.                 fprintf(outputFile,"tDDt%s",buf);
  883.                 outcol = 26 + strlen(sp->name);
  884.                 gentype = longgen;
  885.                 }
  886. }
  887. }
  888. void genpcref(SYM *sp,int offset)
  889. /*
  890.  * Output a reference to the code area (also gens fixups )
  891.  */
  892. {
  893. genref(sp,offset);
  894. }
  895. void genstorage(int nbytes)
  896. /*
  897.  * Output bytes of storage
  898.  */
  899. { if (prm_asmfile) {
  900. if (!newlabel)
  901. nl();
  902. else newlabel = FALSE;
  903. if (prm_nasm)
  904.          fprintf(outputFile,"tRESBt0%XH",nbytes);
  905. else
  906.          fprintf(outputFile,"tDBt0%XH DUP (?)",nbytes);
  907. outcol = 28;
  908. gentype = storagegen;
  909. }
  910. }
  912. void gen_labref(int n)
  913. /*
  914.  * Generate a reference to a label
  915.  */
  916. { if (prm_asmfile)
  917.         if( gentype == longgen && outcol < 58) {
  918.                 fprintf(outputFile,",L_%d",n);
  919.                 outcol += 6;
  920.                 }
  921.         else    {
  922. if (!newlabel)
  923. nl();
  924. else newlabel = FALSE;
  925.                 fprintf(outputFile,"tDDtL_%d",n);
  926.                 outcol = 22;
  927.                 gentype = longgen;
  928.                 }
  929. }
  931. int     stringlit(char *s, int uselong)
  932. /*
  933.  *      make s a string literal and return it's label number.
  934.  */
  935. {       struct slit     *lp;
  936.         ++global_flag;          /* always allocate from global space. */
  937.         lp = xalloc(sizeof(struct slit));
  938.         lp->label = nextlabel++;
  939. if (uselong) 
  940. lp->str = plitlate(s);
  941. else
  942.          lp->str = litlate(s);
  943.         lp->next = strtab;
  944. lp->type = uselong;
  945.         strtab = lp;
  946.         --global_flag;
  947.         return lp->label;
  948. }
  950. void dumplits(void)
  951. /*
  952.  *      dump the string literal pool.
  953.  */
  954. {
  955.         while( strtab != 0) {
  956.                 cseg();
  957.                 nl();
  958.                 put_label(strtab->label);
  959. genstring(strtab->str,strtab->type);
  960. if (strtab->type)
  961. genword(0);
  962. else
  963. genbyte(0);
  964.                 strtab = strtab->next;
  965.                 }
  966.         nl();
  967. }
  969. /*
  970.  * Exit if from a special segment
  971.  */
  972. void exitseg(void)
  973. {
  974. if (!prm_nasm) {
  975. if (curseg == startupxseg) {
  976. curseg = noseg;
  977. fprintf(outputFile,"cstartuptENDSn");
  978. }
  979. else if (curseg == rundownxseg) {
  980. curseg = noseg;
  981. fprintf(outputFile,"crundowntENDSn");
  982. }
  983. else if (curseg == cppxseg) {
  984. curseg = noseg;
  985. fprintf(outputFile,"cppinittENDSn");
  986. }
  987. }
  988. }
  989. /*
  990.  * Switch to cseg 
  991.  */
  992. void cseg(void)
  993. { if (prm_asmfile)
  994.         if( curseg != codeseg) {
  995.                 nl();
  996. exitseg();
  997. if (prm_nasm)
  998.                  fprintf(outputFile,"[SECTION .text]n");
  999. else
  1000.                  fprintf(outputFile,"t.CODEn");
  1001.                 curseg = codeseg;
  1002.                 }
  1003. }
  1004. /*
  1005.  * Switch to deseg
  1006.  */
  1007. void dseg(void)
  1008. {     if (prm_asmfile)  
  1009. if( curseg != dataseg) {
  1010.                 nl();
  1011. exitseg();
  1012. if (prm_nasm)
  1013.                  fprintf(outputFile,"[SECTION .data]n");
  1014. else
  1015.                  fprintf(outputFile,"t.DATAn");
  1016.                 curseg = dataseg;
  1017.                 }
  1018. }
  1019. /*
  1020.  * Switch to bssseg
  1021.  */
  1022. void bssseg(void)
  1023. {     if (prm_asmfile)  
  1024. if( curseg != bssxseg) {
  1025.                 nl();
  1026. exitseg();
  1027. if (prm_nasm)
  1028.                  fprintf(outputFile,"[SECTION .bss]n");
  1029. else
  1030.                  fprintf(outputFile,"t.DATA?n");
  1031.                 curseg = bssxseg;
  1032.                 }
  1033. }
  1034. /*
  1035.  * Switch to startupseg
  1036.  */
  1037. void startupseg(void)
  1038. {     if (prm_asmfile)  
  1039. if( curseg != startupxseg) {
  1040.                 nl();
  1041. exitseg();
  1042. if (prm_nasm)
  1043.                  fprintf(outputFile,"[SECTION cstartup]n");
  1044. else
  1045.                  fprintf(outputFile,"cstartuptSEGMENT USE32 PUBLIC DWORD 42INITDATA42n");
  1046.                 curseg = startupxseg;
  1047.                 }
  1048. }
  1049. /*
  1050.  * Switch to rundownseg
  1051.  */
  1052. void rundownseg(void)
  1053. {     if (prm_asmfile)  
  1054. if( curseg != rundownxseg) {
  1055.                 nl();
  1056. exitseg();
  1057. if (prm_nasm)
  1058.                 fprintf(outputFile,"[SECTION crundown]n");
  1059. else
  1060.                  fprintf(outputFile,"crundowntSEGMENT USE32 PUBLIC DWORD 42EXITDATA42n");
  1061.                 curseg = rundownxseg;
  1062.                 }
  1063. }
  1064. void cppseg(void)
  1065. {     if (prm_asmfile)  
  1066. if( curseg != cppxseg) {
  1067.                 nl();
  1068. exitseg();
  1069. if (prm_nasm)
  1070.                  fprintf(outputFile,"[SECTION cppinit]n");
  1071. else
  1072.                  fprintf(outputFile,"cppinittSEGMENT USE32 PUBLIC DWORD 42CPPDATA42n");
  1073.                 curseg = cppxseg;
  1074.                 }
  1075. }
  1076. void gen_virtual(char *name)
  1077. {
  1078. if (prm_asmfile) {
  1079. nl();
  1080. fprintf(outputFile,"@%stSEGMENT VIRTUAL",name);
  1081. }
  1082. }
  1083. void gen_endvirtual(char *name)
  1084. {
  1085. if (prm_asmfile) {
  1086. nl();
  1087. fprintf(outputFile,"@%stENDS",name);
  1088. }
  1089. }
  1090. /*
  1091.  * Align
  1092.  */
  1093. void align(int size)
  1094. {
  1095. if (prm_asmfile) {
  1096. nl();
  1097. if (prm_nasm)
  1098. /* NASM 0.91 wouldn't let me use parenthesis but this should work
  1099.  * according to the documented precedence levels
  1100.  */
  1101. fprintf(outputFile,"tTIMES $$-$ & %d NOPn",3);
  1102. else
  1103. fprintf(outputFile,"tALIGNt%dn",4);
  1104. }
  1105. }
  1106. /* muldiv val init
  1107.  */
  1108. void init_muldivval(void)
  1109. {
  1110. muldivlink = 0;
  1111. }
  1112. /*
  1113.  * queue muldiv val
  1114.  */
  1115. void queue_muldivval(int label, long number)
  1116. {
  1117. MULDIV *p = xalloc(sizeof(MULDIV));
  1118. p->link = muldivlink;
  1119. p->value = number;
  1120. p->label = label;
  1121. p->size = 0;
  1122. muldivlink = p;
  1123. }
  1124. void queue_floatval(int label, double number, int size)
  1125. {
  1126. MULDIV *p = xalloc(sizeof(MULDIV));
  1127. p->link = muldivlink;
  1128. p->floatvalue = number;
  1129. p->label = label;
  1130. p->size = size;
  1131. muldivlink = p;
  1132. }
  1133. void dump_muldivval(void)
  1134. {
  1135. int tag = FALSE;
  1136. if (prm_asmfile) {
  1137. fprintf(outputFile,"n");
  1138. if (muldivlink) {
  1139. tag = TRUE;
  1140. align(4);
  1141. }
  1142. while (muldivlink) {
  1143. put_label(muldivlink->label);
  1144. if (muldivlink->size == 0)
  1145. fprintf(outputFile,"tDDt0%xHn",muldivlink->value);
  1146. else if (muldivlink->size == 6)
  1147. fprintf(outputFile,"tDDt%fn",muldivlink->floatvalue);
  1148. else if (muldivlink->size == 8)
  1149. fprintf(outputFile,"tDQt%fn",muldivlink->floatvalue);
  1150. else
  1151. fprintf(outputFile,"tDTt%fn",muldivlink->floatvalue);
  1152. muldivlink = muldivlink->link;
  1153. }
  1154. if (tag)
  1155. fprintf(outputFile,"n");
  1156. }
  1157. }
  1158. void asm_header(void)
  1159. {
  1160. nl();
  1161. if (prm_nasm)
  1162. fprintf(outputFile,"[BITS 32]nn");
  1163. else {
  1164. fprintf(outputFile,"tTITLEt'%s'n",outfile);
  1165. if (prm_flat)
  1166. fprintf(outputFile,"t.486pnt.MODEL FLATnn");
  1167. else
  1168. fprintf(outputFile,"t.486pnt.MODEL SMALLnn");
  1169. }
  1170. }
  1171. void globaldef(SYM *sp)
  1172. {
  1173. char buf[100],*q=buf,*p=sp->name;
  1174. if (curseg == codeseg && currentfunc->pascaldefn) {
  1175. if (prm_cmangle)
  1176. p++;
  1177. while(*p)
  1178. *q++=toupper(*p++);
  1179. *q++ = 0;
  1180. }
  1181. else
  1182. strcpy(buf,p);
  1183. if (prm_nasm)
  1184.       fprintf(outputFile,"[GLOBALt%s]n",buf);
  1185. else
  1186.       fprintf(outputFile,"tPUBLICt%sn",buf);
  1187. }
  1188. void putexterns(void)
  1189. /*
  1190.  * Output the fixup tables and the global/external list
  1191.  */
  1192. {       SYM     *sp;
  1193. int i;
  1194. if (prm_asmfile){
  1195. int notyet = TRUE;
  1196. nl();
  1197. exitseg();
  1198. for (i=0; i < HASHTABLESIZE; i++) {
  1199. if ((sp=(SYM *) globalhash[i]) != 0) {
  1200. while (sp) {
  1201.           if( sp->storage_class == sc_externalfunc && sp->extflag) {
  1202. char buf[100],*q=buf,*p=sp->name;
  1203. if (curseg == codeseg && sp->pascaldefn) {
  1204. if (prm_cmangle)
  1205. p++;
  1206. while(*p)
  1207. *q++=toupper(*p++);
  1208. *q++ = 0;
  1209. }
  1210. else
  1211. strcpy(buf,p);
  1212. if (prm_nasm) {
  1213.   if (notyet) {
  1214. fprintf(outputFile,"n[SECTION .text]n");
  1215. notyet = FALSE;
  1216. }
  1217.                  fprintf(outputFile,"[EXTERNt%s]n",buf);
  1218. }
  1219. else {
  1220.   if (notyet) {
  1221. fprintf(outputFile,"nt.CODEn");
  1222. notyet = FALSE;
  1223. }
  1224.                  fprintf(outputFile,"tEXTRNt%s:PROCn",buf);
  1225. }
  1226. }
  1227.           sp = sp->next;
  1228. }
  1229. }
  1230. }
  1231. notyet = TRUE;
  1232. for (i=0; i < HASHTABLESIZE; i++) {
  1233. if ((sp=(SYM *) globalhash[i]) != 0) {
  1234. while (sp) {
  1235.          if( sp->storage_class == sc_external && sp->extflag) {
  1236. char buf[100],*q=buf,*p=sp->name;
  1237. if (curseg == codeseg && sp->pascaldefn) {
  1238. if (prm_cmangle)
  1239. p++;
  1240. while(*p)
  1241. *q++=toupper(*p++);
  1242. *q++ = 0;
  1243. }
  1244. else
  1245. strcpy(buf,p);
  1246.   if (prm_nasm) {
  1247.   if (notyet) {
  1248. fprintf(outputFile,"n[SECTION .data]n");
  1249. notyet = FALSE;
  1250. }
  1251.                  fprintf(outputFile,"[EXTERNt%s]n",buf);
  1252.   }
  1253.   else {
  1254. if (notyet) {
  1255. fprintf(outputFile,"nt.DATAn");
  1256. notyet = FALSE;
  1257. }
  1258.                  fprintf(outputFile,"tEXTRNt%sn",buf);
  1259.   }
  1260. }
  1261.           sp = sp->next;
  1262. }
  1263. }
  1264. }
  1265. if (!prm_nasm)
  1266. fprintf(outputFile,"tENDn");
  1267. }
  1268. }