cc386.p

CC386 is a general-purpose 32-bit C compiler. It is not an optimizing compiler but given that the co

/* Protogen Version 1.00 Sunday November 15, 1998  14:00:17 */

                             /* Gexpr386.c */

AMODE *floatconvpos(void);
int chksize(int lsize, int rsize);
AMODE *fstack(void);
AMODE		*make_muldivval(AMODE *ap);
void make_floatconst(AMODE *ap);
AMODE    *make_label(int lab);
AMODE    *make_immed(long i);
AMODE    *make_immedt(long i, int size);
AMODE    *make_offset(ENODE *node);
AMODE *make_seg(int seg);
AMODE *make_stack(int number);
AMODE *makesegreg(int seg);
AMODE * floatstore(ENODE *node, AMODE *apr, int novalue, int size);
void floatload(AMODE *ap, int flag);
int is_memory(AMODE *ap);
AMODE *bit_load(AMODE *ap,ENODE *node);
void bit_store(AMODE *ap2, AMODE *ap1, ENODE *node, int novalue);
void do_extend(AMODE *ap,int osize,int flags);
int     isshort(ENODE *node);
int     isbyte(ENODE *node);
int depth(ENODE *node);                                           /* STATIC */
void noids(AMODE *ap);
AMODE *indx_data(AMODE *ap);
AMODE *doindex(ENODE *node, enum e_node type);
AMODE    *gen_index(ENODE *node);
AMODE    *gen_deref(ENODE *node, int size);
void get_size(AMODE *ap1, AMODE *ap2,int size, int flags);
void small_size(AMODE *ap1, AMODE *ap2, int size, int flags);
void resolve_binary(ENODE *node,AMODE **ap1, AMODE **ap2, int size);
int isbit(ENODE *node);                                           /* STATIC */
int as_args(ENODE *node,AMODE **apr,AMODE **ap1,AMODE **ap2, int size,int shift);/* STATIC */
int prefer(ENODE *node,AMODE **ap2, AMODE **ap3, int op, int dosizing, int size);/* STATIC */
AMODE    *gen_unary(ENODE *node,int op, int fop, int size);
AMODE *gen_fbinary(ENODE *node,int fop, int fopp, int fopr,int foppr,int size, AMODE **apr);
AMODE    *gen_xbin(ENODE *node,int op,int op2, int size);
AMODE    *gen_binary(ENODE *node,int op, int fopp, int fop, int foppr, int fopr, int size);
void doshift(AMODE *ap1, AMODE *ap2, int op, int div, int size);
AMODE    *gen_shift(ENODE *node, int op,int size,int div);
void divintoeax(AMODE *ap1, int size, int op, int modflag);
void dodiv(AMODE *ap1, AMODE *ap2, int op,int modflag);
AMODE    *gen_modiv(ENODE *node, int op, int fopp, int fop, int foppr, int fopr, int modflag,int size);
AMODE * gen_pdiv(ENODE *node,int size);
int domul(AMODE *ap1, AMODE *ap2, int op);
AMODE * gen_pmul(ENODE *node,int size);
AMODE    *gen_mul(ENODE *node, int op,int fopp,int fop, int foppr, int fopr, int size);
AMODE    *gen_hook(ENODE *node,int size);
AMODE    *gen_asunary(ENODE *node,int novalue,int op, int fop, int size);
AMODE    *gen_asadd(ENODE *node,int novalue,int op,int fopp,int fop, int foppr, int fopr,int size);
AMODE    *gen_aslogic(ENODE *node, int novalue, int op, int op2, int size);
AMODE *gen_asshift(ENODE *node, int novalue,int op, int size, int div);
AMODE    *gen_asmul(ENODE *node, int novalue,int op, int foppr, int fopr, int fopp, int fop,int size);
AMODE    *gen_asmodiv(ENODE *node, int novalue, int op, int fopp, int fop, int foppr, int fopr, int modflag,int size);
void mov1(AMODE *dst, AMODE *src, int size);
void mov2(AMODE *dst, AMODE *src, int size1,int size2);
void mov3(AMODE *dst, AMODE *src, int size1,int size2,int size3);
AMODE *amode_moveblock(AMODE *ap1, AMODE *ap2, int size);
AMODE *gen_moveblock(ENODE *node)      ;
AMODE    *gen_assign(ENODE *node, int novalue,int size, int stdc);
AMODE    *gen_refassign(ENODE *node, int novalue, int size);
AMODE    *gen_aincdec(ENODE *node, int novalue, int op, int size);
int push_param(ENODE *ep, int size);
int push_stackblock(ENODE *ep);
int     gen_parms(ENODE *plist);
AMODE    *gen_tcall(ENODE *node, int novalue);
AMODE    *gen_fcall(ENODE *node, int novalue);
AMODE    *gen_pfcall(ENODE *node, int novalue);
AMODE    *gen_expr(ENODE *node, int novalue, int adronly, int size);
AMODE	   *gen_void(ENODE *node);
int     natural_size(ENODE *node);
int defcond(ENODE *node) ;                                        /* STATIC */
AMODE *truerelat(ENODE *node);                                    /* STATIC */
int complex_relat(ENODE *node);                                   /* STATIC */
AMODE *gen_relat(ENODE *node);
AMODE *gen_compare(ENODE *node, int btype1, int btype2, int btype3, int btype4, int fbtype1, int fbtype2,int label);
void truejp(ENODE *node, int label);
void falsejp(ENODE *node, int label);

                             /* Gstmt386.c */

AMODE    *makedreg(int r);
AMODE    *makefreg(int r);
AMODE    *make_direct(int i);
AMODE    *make_strlab(char *s);
void genwhile(SNODE *stmt);
void gen_for(SNODE *stmt);
void genif(SNODE *stmt);
void gendo(SNODE *stmt);
AMODE *set_symbol(char *name,int flag);
void call_library(char *lib_name);
void gencase(SNODE *stmt);
void genxswitch(SNODE *stmt);
void AddProfilerData(void);
void SubProfilerData(void);
AMODE *genreturn(SNODE *stmt, int flag);
void genstmt(SNODE *stmt);
void scppinit(void);
void gen_vtab(SYM *sp);
void genfunc(SNODE *stmt);

                             /* Outas386.c */

void outcodeini(void);
void nl(void);
void outop(char *name);
void putop(enum e_op op, AMODE *aps, AMODE *apd, int nooptx);
void putconst(ENODE *offset);
void putlen(int l);
void putsizedreg(char *string, int reg, int size);
void pointersize(int size);
void putseg(int seg, int usecolon);
void putamode(AMODE *ap);
void put_code(OCODE *cd);
void putsym(char *buf, SYM *sp, char *p);
void gen_strlab(SYM *s);
void put_label(int lab);
void put_staticlabel(long label);
void genfloat(long double val);
void gendouble(long double val);
void genlongdouble(long double val);
int genstring(char *str, int uselong,int len);
void genbyte(long val);
void genword(long val);
void genlong(long val);
void genlonglong(LLONG_TYPE val);
void gensrref(SYM *sp, int val);
void genref(SYM *sp,int offset);
void genpcref(SYM *sp,int offset);
void genstorage(int nbytes);
void gen_labref(int n);
int     stringlit(char *s, int uselong,int len);
void dumplits(void);
void exitseg(void);
void cseg(void);
void xconstseg(void) ;
void xstringseg(void) ;
void dseg(void);
void bssseg(void);
void startupseg(void);
void rundownseg(void);
void cppseg(void);
void gen_virtual(SYM *sp, int data);
void gen_endvirtual(SYM *sp);
SYM *gen_mp_virtual_thunk(SYM *vsp);
SYM *gen_vsn_virtual_thunk(SYM *func, int ofs) ;
void align(int size);
long queue_muldivval(long number);
long queue_floatval(long double number, int size);
void dump_muldivval(void);
void asm_header(void);
void globaldef(SYM *sp);
void output_alias(char *name, char *alias);
void putexterns(void);

                              /* Peep386.c */

void peepini(void);
AMODE    *copy_addr(AMODE *ap);
OCODE *gen_code(int op,AMODE *ap1,AMODE *ap2);
OCODE *gen_code3(int op,AMODE *ap1,AMODE *ap2, AMODE *ap3) ;
OCODE *gen_codes(int op, int len, AMODE *ap1, AMODE *ap2);
void gen_coden(int op, int len, AMODE *ap1, AMODE *ap2);
void gen_codefs(int op, int len, AMODE *ap1, AMODE *ap2);
void gen_codef(int op, AMODE *ap1, AMODE *ap2);
void gen_codes2(int op, int len, AMODE *ap1, AMODE *ap2);
void gen_code2(int op, int len1, int len2, AMODE *ap1, AMODE *ap2);
void gen_codelab(SYM *lab);
void gen_virtlab(SYM *lab);
void gen_virtendlab(SYM *lab);
void gen_branch(int op,AMODE *ap1);
void gen_line(SNODE *stmt);
void gen_comment(char *txt);
void add_peep(OCODE *new);
void gen_label(int labno);
void flush_peep(void);
void peep_add(OCODE *ip);
void peep_sub(OCODE *ip);
int makeshl(ENODE *node, int scale, int *rv) ;
void peep_lea2(OCODE *ip, AMODE *ap);
void peep_lea(OCODE *ip);
void peep_signextend(OCODE *ip);
void replacereg(AMODE *ap, int reg,int reg2);
OCODE *peep_test(OCODE *ip);
void peep_cmp(OCODE *ip);
void peep_mov(OCODE *ip);
void peep_and(OCODE *ip);
void peep_neg(OCODE *ip);
void peep_btr(OCODE *ip);
OCODE *peep_jmp(OCODE *ip);
void peep_uctran(OCODE *ip);
void peep_label(OCODE *ip);
int novalue(OCODE *ip);
int equal_address(AMODE *ap1,AMODE *ap2);
int single_bit(int val);
void peep_prefixes(OCODE *ip);
void remove_peep_entry(OCODE *ip);
void opt3(void);

                              /* Reg386.c */

void regini(void);
void set_func_mode(int mode) ;
void gen_push(int reg, int rmode, int flag);
void gen_pop(int reg, int rmode, int flag);
void pushregs(unsigned mask);
void popregs(unsigned mask);
void initstack(void);
AMODE *translate_stacktemp(AMODE *ap, int store);
int install_tempreg(AMODE *ap, AMODE *ap2);
int next_dreg(void);
AMODE *only_data(void);
AMODE    *temp_data(void);
void freedata(int dreg);
void freeop(AMODE *ap);

                               /* An386.c */

void reserveregs(int *datareg, int *addreg, int *floatreg);
void allocate(int datareg, int addreg, int floatreg, SNODE *block );
void loadregs(void);
void asm_scannode (ENODE *node);
void asm_scan1(AMODE *ap);
void asm_scan(OCODE *cd);
void asm_repnode(ENODE **node);
int voidexpr(ENODE *node);
void voidfloat(SNODE *block);
void asm_repcse1(AMODE *ap);
void asm_repcse(OCODE *cd);

                              /* Conf386.c */

int confcodegen(char s, int bool);
void confsetup(void);
int     alignment(int type, TYP *tp);
int getalign(int sc, TYP *tp);
long getautoval(long val);
int funcvaluesize(int size);

/* Protogen Version 1.00 Sunday November 15, 1998  14:00:17 */

                             /* Inasm386.c */

void inasmini(void);
int asm_enterauto(ENODE *node, int *reg1, int *reg2);
int isrm(AMODE* ap, int dreg_allowed);
AMODE *getimmed(void);
enum e_op asm_op(void);
SNODE *asm_statement (int shortfin);
/* Protogen Version 1.00 Friday October 19, 2001  18:29:57 */

                             /* Outco386.c */

void outcode_file_init(void);
void outcode_func_init(void);
void InsertLabel(int lbl, int address, int seg);
int LabelAddress(int lbl);
int LabelSeg(int lbl);
void InsertLine(int address, int line, int file);
EMIT_TAB *gettab(int seg);
void emit(int seg, BYTE *data, int len);
void write_to_seg(int seg, int offset, char *value, int len);
void gen_symbol_fixup(enum mode xmode, int seg, int address, SYM *pub);
void gen_label_fixup(enum mode xmode , int seg, int address, int lab);
void outcode_dump_muldivval(void);
void outcode_dumplits(void);
void outcode_genref(SYM *sp, int offset);
void outcode_gen_labref(int n);
void outcode_gensrref(SYM *sp, int val);
void outcode_genstorage(int len);
void outcode_genfloat(long double val);
void outcode_gendouble(long double val);
void outcode_genlongdouble(long double val);
void outcode_genstring(char *string, int len);
void outcode_genbyte(int val);
void outcode_genword(int val);
void outcode_genlong(int val);
void outcode_genlonglong(LLONG_TYPE val);
void outcode_align(int size);
void outcode_put_label(int lab);
void outcode_start_virtual_seg(SYM *sp, int data);
void outcode_end_virtual_seg(SYM *sp);
ENODE *GetSymRef(ENODE *n);
int resolveoffset(OCODE *ins, ENODE *n, int *resolved);
int asmrm(int reg, OCODE *ins, AMODE *data, BYTE **p);
int asmfrm(int reg, OCODE *ins, AMODE *data, BYTE **p);
int outcode_AssembleIns(OCODE *ins, int address);
void outcode_optimize(OCODE *peeplist);
void outcode_dumpIns(OCODE *peeplist);
void outcode_gen(OCODE *peeplist);