outx86_n.c

一款拥有一定历史的C语言编译器

#ifdef FLOAT_IEEE
    if (sa & FP) {
	/* assume that st(n) never appears explicitly as an operand here */
	putlen (len);
    }
#endif
    switch (ap->mode) {
    case am_immed:
	if (sa & BI) {
	    switch (ap->u.offset->nodetype) {
	    case en_labcon:
	    case en_nacon:
		oprintf ("offset ");
		break;
	    default:
		break;
	    }
	}
	putconst (ap->u.offset);
	break;
    case am_direct:
	putlen (len);
	if (sa & BI) {
	    oprintf ("[");
	    putconst (ap->u.offset);
	    oprintf ("]");
	} else {
	    putconst (ap->u.offset);
	}
	break;
    case am_dreg:
    case am_areg:
	reg = ap->preg;
	switch (len) {
	case IL1:
	    reg = REG8 (reg);
	    break;
	case IL2:
	    reg = REG16 (reg);
	    break;
	default:
	    break;
	}
	oprintf ("%s", regname[reg]);
	break;
    case am_indx:
	putlen (len);
	oprintf ("[%s", regname[small_option ? REG16 (ap->preg) : ap->preg]);
	if (ap->u.offset != NIL_EXPR) {
	    putconst (ap->u.offset);
	}
	oprintf ("]");
	break;
    case am_ind:
	oprintf ("[%s]", regname[small_option ? REG16 (ap->preg) : ap->preg]);
	break;
    case am_indx2:
	putlen (len);
	oprintf ("[%s+%s",
		 regname[small_option ? REG16 (ap->preg) : ap->preg],
		 regname[small_option ? REG16 (ap->sreg) : ap->sreg]);
	if (ap->u.offset != NIL_EXPR) {
	    putconst (ap->u.offset);
	}
	oprintf ("]");
	break;
    case am_freg:
	oprintf ("%s", regname[ap->preg]);
	break;
    case am_line:
    case am_str:
	putconst (ap->u.offset);
	break;
    default:
	FATAL ((__FILE__, "putamode", "illegal address mode %d", ap->mode));
	break;
    }
}

/*
 * output a generic instruction.
 */
PRIVATE void put_code P1 (const CODE *, ip)
{
    ILEN    len1 = ip->length, len2 = ip->length;
    int     sa;

    sa = putop (ip->opcode);
    /*
     * this is expensive, but some assemblers require it
     * this is to be moved to the peephole optimizer
     */
    switch (ip->opcode) {
    case op_shl:
    case op_shr:
    case op_asl:
    case op_asr:
	len1 = IL1;
	break;
    case op_movsbw:
    case op_movzbw:
	len2 = IL2;
	/*FALLTHRU */
    case op_movsbl:
    case op_movzbl:
	len1 = IL1;
	break;
    case op_movswl:
    case op_movzwl:
	len1 = IL2;
	break;
    case op_smov:
	switch (ip->length) {
	case IL1:
	    oprintf ("b");
	    break;
	case IL2:
	    oprintf ("w");
	    break;
	case IL4:
	    oprintf ("d");
	    break;
	default:
	    FATAL (
		   (__FILE__, "putcode", "illegal length field %d",
		    (int) ip->length));
	    break;
	}
	break;
    default:
	break;
    }

    /*
     * Masm uses the INTEL syntax:
     * The destination comes first
     * The source comes second
     */
    if (ip->oper1 != NIL_ADDRESS) {
	oprintf ("\t");
	if (ip->oper2 != NIL_ADDRESS &&
	    ip->opcode != op_line && ip->opcode != op_idiv) {
	    putamode (ip->oper2, len2, sa);
	    oprintf (", ");
	}
	putamode (ip->oper1, len1, sa);
	if (ip->oper2 != NIL_ADDRESS && ip->opcode == op_line) {
	    oprintf ("%s%s>>>>\t", newline, comment);
	    putamode (ip->oper2, len2, sa);
	}
    }
    oprintf ("%s", newline);
}

/*
 * generate a named label.
 */
PRIVATE void put_name P1 (SYM *, sp)
{
    put_reference (sp);
    oprintf ("%s:%s", outlate (nameof (sp)), newline);
}

/*
 * output a compiler generated label.
 */
PRIVATE void put_label P1 (LABEL, lab)
{
    oprintf ("%s%u:%s", prefix, (unsigned int) lab, newline);
}

static void put_header P2 (enum e_gt, gtype, SIZE, al)
{
    static const char *directive[] = {
	"db\t",			/* bytegen */
	"dw\t",			/* wordgen */
	"dd\t",			/* longgen */
	"dd\t",			/* longlonggen */
    };

    if (gentype != gtype || outcol >= MAX_WIDTH) {
	put_align (al);
	gentype = gtype;
	outcol = 15;
	oprintf ("\t%s", directive[gtype]);
    } else {
	oprintf (",");
    }
}

PRIVATE void put_byte P1 (UVAL, val)
{
    put_header (bytegen, alignment_of_type (tp_char));
    oprintf ("0x%lx", val & OxffUL);
    outcol += 4;
}

PRIVATE void put_word P1 (UVAL, val)
{
    put_header (wordgen, alignment_of_type (tp_short));
    oprintf ("0x%lx", val & OxffffUL);
    outcol += 6;
}

PRIVATE void put_dword P1 (UVAL, val)
{
    put_header (longgen, alignment_of_type (tp_long));
    oprintf ("0x%lx", val);
    outcol += 10;
}

#ifndef FLOAT_BOOTSTRAP
#ifdef FLOAT_IEEE
/*
 * Generate IEEE single and double numbers
 */
PRIVATE void put_float P1 (const RVAL *, vp)
{
    unsigned long ul;

    ieee_single (vp, &ul);
    put_dword (ul);
}

PRIVATE void put_double P1 (const RVAL *, vp)
{
    unsigned long ul[2];

    ieee_double (vp, ul, FALSE);
    put_dword (ul[0]);
    put_dword (ul[1]);
}

PRIVATE void put_longdouble P1 (const RVAL *, vp)
{
    unsigned long ul[3];

    ieee_longdouble (vp, ul, FALSE);
    put_dword (ul[0]);
    put_dword (ul[1]);
    put_dword (ul[2]);
}

#endif /* FLOAT_IEEE */
#endif /* FLOAT_BOOTSTRAP */

#ifndef RELOC_BUG
PRIVATE void put_char P1 (const EXPR *, ep)
{
    put_header (bytegen, alignment_of_type (tp_char));
    putconst (ep);
    outcol += 10;
}

PRIVATE void put_short P1 (const EXPR *, ep)
{
    put_header (wordgen, alignment_of_type (tp_short));
    putconst (ep);
    outcol += 10;
}

#endif /* RELOC_BUG */

PRIVATE void put_long P1 (const EXPR *, ep)
{
    put_header (longgen, alignment_of_type (tp_long));
    putconst (ep);
    outcol += 10;
}

PRIVATE void put_longlong P1 (const EXPR *, ep)
{
    put_header (longlonggen, alignment_of_type (tp_longlong));
    putconst (ep);
    outcol += 10;
}

PRIVATE void put_pointer P1 (const EXPR *, ep)
{
    put_header ((tp_pointer->size == 2L ? wordgen : longgen),
		alignment_of_type (tp_pointer));
    putconst (ep);
    outcol += 10;
}

/*ARGSUSED */
PRIVATE void put_storage P1 (SYM *, sp)
{
    SIZE    size = typeof (sp)->size;

    put_bseg (alignment_of_type (typeof (sp)));
    if (is_static (sp)) {
	oprintf ("%s%u\ttimes\t%ld db 0%s", prefix, (unsigned) sp->value.l,
		 size, newline);
    } else {
	oprintf ("%s\ttimes\t%ld db 0%s", outlate (nameof (sp)), size,
		 newline);
    }
}


/*
 * dump the string literal pool.
 */
PRIVATE void put_literals P0 (void)
{
    const CHAR *cp;
    size_t  len;

    if (lang_option == LANG_KANDR) {
	put_dseg (alignment_of_type (tp_char));
    } else {
	put_kseg (alignment_of_type (tp_char));
    }
    for (; strtab != NIL_STRING; strtab = strtab->next) {
	nl ();
	put_label (strtab->label);
	cp = strtab->str;
	for (len = strtab->len; len--;)
	    put_byte ((UVAL) *cp++);
	put_byte (Ox0UL);
    }
    nl ();
}

/*
 * write out the type of the symbol
 */
static void puttype P1 (const TYP *, tp)
{
    if (tp == NIL_TYP) {
	/* runtime support routine */
	oprintf ("far");
	return;
    }
    switch (tp->type) {
    case bt_char:
    case bt_schar:
    case bt_uchar:
    case bt_charu:
	oprintf ("byte");
	break;
    case bt_short:
    case bt_ushort:
    case bt_int16:
    case bt_uint16:
    case bt_pointer16:
	oprintf ("word");
	break;
    case bt_int32:
    case bt_uint32:
    case bt_long:
    case bt_ulong:
    case bt_pointer32:
	oprintf ("dword");
	break;
    case bt_float:
	oprintf ("real4");
	break;
    case bt_double:
    case bt_longdouble:
	oprintf ("real8");
	break;
    case bt_func:
	oprintf ("far");
	break;
    default:
	oprintf ("byte");
	break;
    }
}

/* put the definition of an external name in the ouput file */
/* assembler can find out about externals itself. This also has the
 * advantage that I don't have to worry if the symbol is in text or
 * data segment. Therefore this function is a noop
 */
PRIVATE void put_reference P1 (SYM *, sp)
{
    if (!is_symbol_output (sp)) {
	switch (storageof (sp)) {
	case sc_global:
	    put_noseg ();
	    oprintf ("[global\t%s]%s", outlate (nameof (sp)), newline);
	    break;
	case sc_external:
	    put_noseg ();
	    oprintf ("[extern\t%s]%s", outlate (nameof (sp)), newline);
	    break;
	default:
	    break;
	}
	symbol_output (sp);
    }
}

/* align the following data */
static void put_align P1 (SIZE, al)
{
    nl ();
    if (al > align_type) {
	switch (al) {
	case 1L:
	case 0L:
	    break;
	case 2L:
	case 4L:
	    break;
	default:
	    FATAL ((__FILE__, "put_align", "align == %ld", al));
	}
    }
    align_type = al;
}

/*
 * output any function epilogue code
 */
PRIVATE void put_epilogue P2 (SYM *, sp, LABEL, label)
{
    sp = sp;			/* keep the compiler quiet */
    label = label;		/* keep the compiler quiet */
}

PRIVATE void nl P0 (void)
{
    if (outcol > 0) {
	oprintf ("%s", newline);
	gentype = nogen;
	outcol = 0;
    }
}

static void seg P3 (enum e_sg, segtype, const char *, segname, SIZE, al)
{
    nl ();
    if (curseg != segtype) {
	oprintf ("[segment %s]%s", segname, newline);
	curseg = segtype;
	align_type = 0L;
    }
    put_align (al);
}

PRIVATE void put_cseg P1 (SIZE, al)
{
    seg (codeseg, "text", al);
}

PRIVATE void put_dseg P1 (SIZE, al)
{
    seg (dataseg, "data", al);
}

static void put_bseg P1 (SIZE, al)
{
    seg (bssseg, "bss", al);
}

PRIVATE void put_kseg P1 (SIZE, al)
{
    put_dseg (al);
}

PRIVATE void put_rseg P1 (SIZE, al)
{
    put_cseg (al);
}

static void put_noseg P0 (void)
{
    nl ();
    if (curseg != noseg) {
	curseg = noseg;
	align_type = 0L;
    }
}

PRIVATE void put_finish P0 (void)
{
}

PRIVATE void put_start P0 (void)
{
    oprintf ("%s Generated by %s (nasm) %s from %s%s",
	     comment, PROGNAME, VERSION, in_file, newline);
    oprintf ("[group group1 bss data]%s", newline);
    oprintf ("[group group2 text]%s", newline);
    put_bseg (0L);
    put_dseg (0L);
    put_cseg (0L);
}


#ifdef MULTIPLE_ASSEMBLERS
struct funcs nasmx86_func = {
    put_code,
    put_name,
    put_label,
    put_byte,
    put_word,
    put_dword,
#ifndef RELOC_BUG
    put_char,
    put_short,
#endif				/* RELOC_BUG */
    put_long,
    put_pointer,
    put_storage,
    put_literals,
    put_finish,
    put_start,
    put_reference,
    put_epilogue,
    put_cseg,
    put_dseg,
    put_kseg,
    put_rseg, 
#ifndef FLOAT_BOOTSTRAP
#ifdef FLOAT_SUPPORT
	put_float,
    put_double,
    put_longdouble,
#endif	/* FLOAT_SUPPORT */
#endif	/* FLOAT_BOOTSTRAP */
    NULL
};

#endif /* MULTIPLE_ASSEMBLERS */
#endif /* TARGET_NASM */
#endif /* INTEL */