/* * C compiler * ========== * * Copyright 1989, 1990, 1991 Christoph van Wuellen. * Credits to Matthew Brandt. * All commercial rights reserved. * * This compiler may be redistributed as long there is no * commercial interest. The compiler must not be redistributed * without its full sources. This notice must stay intact. * * History: * * 1989   starting an 68000 C compiler, starting with material *        originally by M. Brandt * 1990   68000 C compiler further bug fixes *        started i386 port (December) * 1991   i386 port finished (January) *        further corrections in the front end and in the 68000 *        code generator. *        The next port will be a SPARC port *//*****************************************************************************/#include "config.h"#ifdef INTEL#ifdef TARGET_MASM#define OUT_MODULE#include "chdr.h"#include "expr.h"#include "cglbdec.h"#include "proto.h"#include "genx86.h"#include "outproto.h"#include "version.h"/********************************************************* Macro Definitions */#define	BI	1U#define SPN	2U#define FP	4U/********************************************************** Type Definitions */enum e_gt{    bytegen, wordgen, longgen, longlonggen, nogen};enum e_sg{    noseg, codeseg, dataseg};/*********************************************** Static Function Definitions */static unsigned int putop P_ ((OPCODE));static void putconst P_ ((const EXPR *));static void putamode P_ ((const ADDRESS *, ILEN, unsigned int));static void put_header P_ ((enum e_gt, SIZE));static void seg P_ ((enum e_sg, const char *, SIZE));static void put_bseg P_ ((SIZE));static void put_noseg P_ ((void));static void nl P_ ((void));static void put_align P_ ((SIZE));/*********************************************** Global Function Definitions */PRIVATE void put_label P_ ((LABEL));PRIVATE void put_byte P_ ((UVAL));PRIVATE void put_dword P_ ((UVAL));PRIVATE void put_cseg P_ ((SIZE));PRIVATE void put_dseg P_ ((SIZE));PRIVATE void put_kseg P_ ((SIZE));PRIVATE void put_rseg P_ ((SIZE));PRIVATE void put_finish P_ ((void));PRIVATE void put_start P_ ((void));PRIVATE void put_reference P_ ((SYM *));/********************************************************** Static Variables *//* variable initialization */static enum e_gt gentype = nogen;static enum e_sg curseg = noseg;static int outcol = 0;static SIZE align_type = 0L;static const char *prefix = "I";static const char *comment = ";";static struct oplst{    const char *s;    unsigned int sa;		/* special addressing modes:				 *    BI      immediate is bracketed,				 *    SPN     size prefix needed.				 *    FP      387 op				 */} opl[] ={    {	"movsx", BI | SPN	/* op_movsbl */    }    , {	"movzx", BI | SPN	/* op_movzbl */    }    , {	"movsx", BI | SPN	/* op_movswl */    }    , {	"movzx", BI | SPN	/* op_movzwl */    }    , {	"movsx", BI | SPN	/* op_movsbw */    }    , {	"movzx", BI | SPN	/* op_movzbw */    }    , {	"cdq", BI | SPN		/* op_cdq */    }    , {	"cwd", BI | SPN		/* op_cwd */    }    , {	"cbw", BI | SPN		/* op_cbw */    }    , {	"mov", BI | SPN		/* op_mov */    }    , {	"xchg", BI | SPN	/* op_xchg */    }    , {	"lea", BI | SPN		/* op_lea */    }    , {	"not", BI | SPN		/* op_not */    }    , {	"neg", BI | SPN		/* op_neg */    }    , {	"add", BI | SPN		/* op_add */    }    , {	"sub", BI | SPN		/* op_sub */    }    , {	"adc", BI | SPN		/* op_adc */    }    , {	"sbb", BI | SPN		/* op_sbb */    }    , {	"imul", BI | SPN	/* op_imul */    }    , {	"idiv", BI | SPN	/* op_idiv */    }    , {	"div", BI | SPN		/* op_div */    }    , {	"and", BI | SPN		/* op_and */    }    , {	"or", BI | SPN		/* op_or */    }    , {	"xor", BI | SPN		/* op_xor */    }    , {	"inc", BI | SPN		/* op_inc */    }    , {	"dec", BI | SPN		/* op_dec */    }    , {	"cmp", BI | SPN		/* op_cmp */    }    , {	"push", BI | SPN	/* op_push */    }    , {	"pop", BI | SPN		/* op_pop */    }    , {	"jmp", SPN		/* op_jmp */    }    , {	"loop", SPN		/* op_loop */    }    , {	"call", SPN		/* op_call */    }    , {	"leave", SPN		/* op_leave */    }    , {	"enter", SPN		/* op_enter */    }    , {	"ret", SPN		/* op_ret */    }    , {	"test", BI | SPN	/* op_test */    }    , {	"jmp", SPN		/* op_bra */    }    , {	"je", SPN		/* op_je */    }    , {	"jne", SPN		/* op_jne */    }    , {	"jl", SPN		/* op_jl */    }    , {	"jle", SPN		/* op_jle */    }    , {	"jg", SPN		/* op_jg */    }    , {	"jge", SPN		/* op_jge */    }    , {	"ja", SPN		/* op_ja */    }    , {	"jae", SPN		/* op_jae */    }    , {	"jb", SPN		/* op_jb */    }    , {	"jbe", SPN		/* op_jbe */    }    , {	"rep", SPN		/* op_rep */    }    , {	"movs", BI | SPN	/* op_smov */    }    , {	"shl", BI | SPN		/* op_shl */    }    , {	"shr", BI | SPN		/* op_shr */    }    , {	"sal", BI | SPN		/* op_asl */    }    , {	"sar", BI | SPN		/* op_asr */    }    , {	"rol", BI | SPN		/* op_rol */    }    , {	"ror", BI | SPN		/* op_ror */    }    , {	"sahf", BI | SPN	/* op_sahf */    }    , {	"sete", SPN		/* op_sete */    }    , {	"setne", SPN		/* op_setne */    }    , {	"setb", SPN		/* op_setb */    }    , {	"setbe", SPN		/* op_setbe */    }    , {	"seta", SPN		/* op_seta */    }    , {	"setae", SPN		/* op_setae */    }    , {	"setl", SPN		/* op_setl */    }    , {	"setle", SPN		/* op_setle */    }    , {	"setg", SPN		/* op_setg */    }    , {	"setge", SPN		/* op_setge */    }    , {	"nop", 0		/* op_nop */    }    ,#ifdef FLOAT_IEEE    {	"fadd", BI | SPN | FP	/* op_fadd */    }    , {	"faddp", BI | SPN | FP	/* op_faddp */    }    , {	"fsub", BI | SPN | FP	/* op_fsub */    }    , {	"fsubp", BI | SPN | FP	/* op_fsubp */    }    , {	"fdiv", BI | SPN | FP	/* op_fdiv */    }    , {	"fdivp", BI | SPN | FP	/* op_fdivp */    }    , {	"fmul", BI | SPN | FP	/* op_fmul */    }    , {	"fmulp", BI | SPN | FP	/* op_fmulp */    }    , {	"fsubr", BI | SPN | FP	/* op_fsubr */    }    , {	"fsubrp", BI | SPN | FP	/* op_fsubrp */    }    , {	"fdivr", BI | SPN | FP	/* op_fdivr */    }    , {	"fdivrp", BI | SPN | FP	/* op_fdivrp */    }    , {	"fld", BI | SPN | FP	/* op_fld */    }    , {	"fldz", BI | SPN | FP	/* op_fldz */    }    , {	"fst", BI | SPN | FP	/* op_fst */    }    , {	"fstp", BI | SPN | FP	/* op_fstp */    }    , {	"fstp st(0)", BI | SPN | FP	/* op_fpop */    }    , {	"fild", BI | SPN | FP	/* op_fild */    }    , {	"fildl", BI | SPN | FP	/* op_fildl */    }    , {	"fistp", BI | SPN | FP	/* op_fistp */    }    , {	"fistpl", BI | SPN | FP	/* op_fistpl */    }    , {	"ftst", BI | SPN | FP	/* op_ftst */    }    , {	"fchs", BI | SPN | FP	/* op_fchs */    }    , {	"fcomp", BI | SPN | FP	/* op_fcomp */    }    , {	"fcompp", BI | SPN | FP	/* op_fcompp */    }    , {	"fnstsw", BI | SPN | FP	/* op_fnstsw */    }    , {	"fwait", BI | SPN | FP	/* op_fwait */    }    ,#endif /* FLOAT_IEEE */#ifdef ASM    {	"", 0			/* op_asm */    }    ,#endif /* ASM */    {	"|.line", 0		/* op_line */    }    , {	(char *) NULL, 0	/* op_label */    }};/*****************************************************************************/static unsigned int putop P1 (OPCODE, op){    if (op >= OP_MIN && op <= OP_MAX && opl[op].s != (char *) 0) {	oprintf ("\t%s", opl[op].s);	return opl[op].sa;    }    FATAL ((__FILE__, "putop", "illegal opcode %d", op));    return 0U;	/*lint !e527*/	/* unreachable */}/* * put a constant to the output file. */static void putconst P1 (const EXPR *, ep){    if (ep == NIL_EXPR) {	FATAL ((__FILE__, "putconst", "ep == 0"));    }    switch (ep->nodetype) {    case en_autocon:    case en_icon:	oprintf ("%ld", ep->v.i);	break;    case en_labcon:	oprintf ("%s%u", prefix, (unsigned) ep->v.l);	break;    case en_nacon:	oprintf ("%s", outlate (ep->v.str));	break;    case en_sym:	oprintf ("%s", outlate (nameof (ep->v.sp)));	break;    case en_add:	oprintf ("(");	putconst (ep->v.p[0]);	oprintf ("+");	putconst (ep->v.p[1]);	oprintf (")");	break;    case en_sub:	oprintf ("(");	putconst (ep->v.p[0]);	oprintf ("-");	putconst (ep->v.p[1]);	oprintf (")");	break;    case en_uminus:	oprintf ("-");	putconst (ep->v.p[0]);	break;    case en_cast:	putconst (ep->v.p[0]);	break;    case en_str:	oprintf ("%s", ep->v.str);	break;    default:	FATAL (	       (__FILE__, "putconst", "illegal constant node %d",		ep->nodetype));	break;    }}/* * append the length field to an instruction. */static void putlen P1 (ILEN, l){    switch (l) {    case IL0:	break;    case IL1:	oprintf ("byte ptr ");	break;    case IL2:	oprintf ("word ptr ");	break;    case IL4:	oprintf ("dword ptr ");	break;    case IL4 + 1:	/*lint !e408*/	/* type mismatch with switch expression */	oprintf ("real4 ptr ");	break;    case IL8 + 1:	/*lint !e408*/	/* type mismatch with switch expression */	oprintf ("real8 ptr ");	break;    case IL10 + 1:	/*lint !e408*/	/* type mismatch with switch expression */	break;    default:	CANNOT_REACH_HERE ();	break;    }}/* * output a general addressing mode. */static void putamode P3 (const ADDRESS *, ap, ILEN, len, unsigned int, sa){    static const char *regname[(int) NUMREG + 1] = {	"eax",			/* EAX */	"edx",			/* EDX */	"ecx",			/* ECX */	"ebx",			/* EBX */	"esi",			/* ESI */	"edi",			/* EDI */	"esp",			/* ESP */	"ebp",			/* EBP */	"ax",			/* AX */	"dx",			/* DX */	"cx",			/* CX */	"bx",			/* BX */	"si",			/* SI */	"di",			/* DI */	"sp",			/* SP */	"bp",			/* BP */	"al",			/* AL */	"dl",			/* DL */	"cl",			/* CL */	"bl",			/* BL */	"st",			/* ST(0) */	"st(1)",		/* ST(1) */	"INVALID_REGISTER",	"INVALID_REGISTER",    };    REG     reg;#ifdef FLOAT_IEEE    if (sa & FP) {