cc68.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 Tuesday June 26, 2001  19:24:35 */

                               /* An68.c */

void reserveregs(int *datareg, int *addreg, int *floatreg);
void allocate(int datareg, int addreg, int floatreg, SNODE *block );
void loadregs(void);
int voidexpr(ENODE *node);
void voidfloat(SNODE *block);
void asm_scan(OCODE *cd);
void asm_repcse(OCODE *cd);

/* Protogen Version 1.00 Tuesday June 26, 2001  19:24:35 */

                              /* Conf68.c */

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

/* Protogen Version 1.00 Tuesday June 26, 2001  19:24:35 */


/* Protogen Version 1.00 Tuesday June 26, 2001  19:24:35 */

                              /* Gstmt68.c */

void genstmtini(void);
AMODE    *makedreg(int r);
AMODE    *makeareg(int r);
AMODE    *makefreg(int r);
AMODE    *make_mask(int mask, int floatflag);
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);
void gen_genword(SNODE *stmt);
AMODE *set_symbol(char *name, int isproc);
AMODE *flush_for_libcall(void);
void call_library2(char *lib_name, int size) ;
AMODE *call_library(char *lib_name,int size);
void genxswitch(SNODE *stmt);
void AddProfilerData(void);
void SubProfilerData(void);
void genreturn(SNODE *stmt,int flag);
void genstmt(SNODE *stmt);
void scppinit(void);
void genfunc(SNODE *stmt);

/* Protogen Version 1.00 Tuesday June 26, 2001  19:24:35 */

                              /* Inasm68.c */

AMODE *asm_amode(void); /* PROTOTYPE */                          /* STATIC */
void asm_err(int errnum);                                         /* STATIC */
int need010(void);
int need020(void);
ENODE *asm_ident(void);                                           /* STATIC */
ENODE * asm_label(void);                                          /* STATIC */
int asm_getsize(void);                                            /* STATIC */
int needsize(int size);                                           /* STATIC */
int wordsize(void);                                               /* STATIC */
int need_freg(AMODE **v);                                         /* STATIC */
int need_adreg(AMODE **v);                                        /* STATIC */
int need_dreg(AMODE **v);                                         /* STATIC */
int need_areg(AMODE **v);                                         /* STATIC */
int asm_enterauto(ENODE *node, int inbr, int *rinbr, int *reg1, int *reg2, int*rt1, int *rt2);
AMODE *asm_mem(void);                                             /* STATIC */
AMODE *asm_movemarg(AMODE *rv);                                   /* STATIC */
AMODE *asm_amode(void);                                           /* STATIC */
AMODE* getbf(void);                                             /* STATIC */
enum e_op asm_op(void);
OCODE *make_ocode(AMODE *ap1, AMODE *ap2, AMODE *ap3);            /* STATIC */
int noincdec(AMODE *ap);                                          /* STATIC */
int dreg(AMODE *ap);                                              /* STATIC */
int vermode(AMODE *ap,int dok, int aok, int pcok, int immok);     /* STATIC */
OCODE *ope_negbcd(void);                                          /* STATIC */
OCODE *ope_math(void);                                            /* STATIC */
OCODE *ope_amath(void);                                           /* STATIC */
OCODE *ope_imath(void);                                           /* STATIC */
OCODE *ope_qmath(void);                                           /* STATIC */
OCODE *ope_log(void);                                             /* STATIC */
OCODE *ope_ilog(void);                                            /* STATIC */
OCODE *ope_shift(void);                                           /* STATIC */
OCODE *ope_bra(void);                                             /* STATIC */
OCODE *ope_bit(void);                                             /* STATIC */
OCODE *ope_bf1(void);                                             /* STATIC */
OCODE *ope_bf2(void);                                             /* STATIC */
OCODE *ope_bf3(void);                                             /* STATIC */
OCODE *ope_ead(void);                                             /* STATIC */
OCODE *ope_ear(void);                                             /* STATIC */
OCODE *ope_ea(void);                                              /* STATIC */
OCODE *ope_cmp(void);                                             /* STATIC */
OCODE *ope_eaa(void);                                             /* STATIC */
OCODE *ope_iea(void);                                             /* STATIC */
OCODE *ope_posbcd(void);                                          /* STATIC */
OCODE *ope_dbr(void);                                             /* STATIC */
OCODE *ope_div(void);                                             /* STATIC */
OCODE *ope_eor(void);                                             /* STATIC */
OCODE *ope_eai(void);                                             /* STATIC */
OCODE *ope_rrl(void);                                             /* STATIC */
OCODE *ope_ext(void);                                             /* STATIC */
OCODE *ope_extb(void);                                            /* STATIC */
OCODE *ope_ai(void);                                              /* STATIC */
OCODE *ope_move(void);                                            /* STATIC */
OCODE *ope_movea(void);                                           /* STATIC */
OCODE *ope_movec(void);                                           /* STATIC */
OCODE *ope_movem(void);                                           /* STATIC */
OCODE *ope_movep(void);                                           /* STATIC */
OCODE *ope_moveq(void);                                           /* STATIC */
OCODE *ope_moves(void);                                           /* STATIC */
OCODE *ope_mul(void);                                             /* STATIC */
OCODE *ope_eab(void);                                             /* STATIC */
OCODE *ope_pack(void);                                            /* STATIC */
OCODE *ope_i(void);                                               /* STATIC */
OCODE *ope_set(void);                                             /* STATIC */
OCODE *ope_d(void);                                               /* STATIC */
OCODE *ope_trapcc(void);                                          /* STATIC */
OCODE *ope_a(void);                                               /* STATIC */
OCODE *ope_fmath(void);                                           /* STATIC */
OCODE *ope_fmathx(void);                                          /* STATIC */
OCODE *ope_fmove(void);                                           /* STATIC */
OCODE *fmovecr(void);                                             /* STATIC */
OCODE *ope_fmovem(void);                                          /* STATIC */
OCODE *ope_fsincos(void);                                         /* STATIC */
OCODE *ope_fone(void);                                            /* STATIC */
void inasmini(void);
SNODE *asm_statement (int shortfin);

/* Protogen Version 1.00 Tuesday June 26, 2001  19:24:35 */

                              /* Intr68.c */

void IntrinsIni(void);
void SearchIntrins(SYM *sp);
int oneparm(ENODE *parms);                                        /* STATIC */
int twoparms(ENODE *parms);                                       /* STATIC */
int threeparms(ENODE *parms);                                     /* STATIC */
AMODE *HandleIntrins(ENODE *node, int novalue);

/* Protogen Version 1.00 Tuesday June 26, 2001  19:24:35 */

                              /* Outas68.c */

void dump_muldivval(void);
void outcodeini(void);
void datalink(int flag);
void nl(void);
void outop(char *name);
void putop(int op);
void putsym(char *buf, SYM *sp, char *p);
void putconst(ENODE *offset);
void putlen(int l);
void putsize(AMODE *ap);
void putamode(AMODE *ap);
void put_code(OCODE *cd);
void put_fmask(int mask);
void put_mask(int mask);
void putreg(int r);
void gen_strlab(SYM *sp);
void put_label(int label);
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 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 cseg(void);
void xconstseg(void);
void xstringseg(void);
void dseg(void);
void bssseg(void);
void startupseg(void);
void rundownseg(void);
void cppseg(void);
void cpprdseg(void);
void gen_virtual(SYM *sp, int data);
void gen_endvirtual(SYM *sp);
SYM *gen_mp_virtual_thunk(SYM *vsp);
void genlongref(DATALINK *p);
void asm_header(void);
void globaldef(SYM *sp);
void output_alias(char *name, char *alias);
void putexterns(void);

/* Protogen Version 1.00 Tuesday June 26, 2001  19:24:35 */

                              /* Peep68.c */

void peepini(void);
AMODE    *copy_addr(AMODE *ap);
void gen_code(int op,AMODE *ap1,AMODE *ap2);
AMODE * gen_codes(int op,int len,AMODE *ap1,AMODE *ap2);
void gen_coden(int op, int len, AMODE *ap1, AMODE *ap2);
void gen_branch(int op,AMODE *ap1);
void gen_codeb(int op, int len, AMODE *ap1, AMODE *ap2);
void gen_lea(int size, AMODE *ap1, AMODE * ap2);
void gen_codelab(SYM *lab);
void gen_line(SNODE *stmt);
void gen_codef(int op, int len, AMODE *ap1, AMODE *ap2);
void gen_code3(int op, int len, AMODE *ap1, AMODE *ap2, AMODE *ap3);
void add_peep(OCODE *new);
void gen_label(int labno);
void flush_peep(void);
void peep_move(OCODE *ip);
int peep_tst(OCODE *ip);
int     equal_address(AMODE *ap1, AMODE *ap2);
void peep_add(OCODE *ip);
void peep_sub(OCODE *ip);
void     peep_cmp(OCODE *ip);
void peep_muldiv(OCODE *ip, int op);
void peep_uctran(OCODE *ip);
void peep_label(OCODE *ip);
void opt3(void);

/* Protogen Version 1.00 Tuesday June 26, 2001  19:24:35 */

                               /* Reg68.c */

void regini(void);
void gen_push(int reg, int rmode, int flag);
void gen_pop(int reg, int rmode, int flag);
void initstack(void);
int next_dreg(void);
int next_areg(void);
int next_freg(void);
AMODE    *temp_data(void);
AMODE    *temp_addr(void);
AMODE    *temp_float(void);
void popa(int reg);
void freedata(int dreg);
void freeaddr(int areg);
void freefloat(int freg);
void freeop(AMODE *ap);
/* Protogen Version 1.00 Tuesday June 26, 2001  19:29:14 */

                              /* Gexpr68.c */

int chksize(int lsize, int rsize);
AMODE    *make_label(int lab);
AMODE    *makebf(ENODE *node, AMODE *ap1, int size);
AMODE    *make_immed(long i);
AMODE    *make_immedt(long i, int size);
AMODE    *make_offset(ENODE *node);
void tofloat(AMODE *ap,int size);
void doshift(int op, AMODE *ap2, AMODE *ap1, int div, int size);
void bit_store(AMODE *ap1,AMODE *ap2,ENODE *node, int novalue);
AMODE *bit_load(AMODE *ap,ENODE *node, int size);
void do_extend(AMODE *ap,int osize,int flags);
AMODE *direct_data(AMODE *ap)     ;
int     isshort(ENODE *node);
int     isbyte(ENODE *node);
int isamshort(AMODE *ap);
int isamshort2(AMODE *ap, AMODE *ap2);
int isambyte(AMODE *ap);
int isambyte2(AMODE *ap, AMODE *ap2);
int depth(ENODE *node);                                           /* STATIC */
void noids(AMODE *ap);
AMODE *ind_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);/* 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 size, AMODE *apr);
AMODE    *gen_binary(ENODE *node,int op, int fop,int size);
AMODE    *gen_xbin(ENODE *node,int op, int op2,int size);
AMODE    *gen_shift(ENODE *node, int op,int div, int size);
AMODE    *gen_modiv(ENODE *node, int op, int fop, int size, int modflag);
void swap_nodes(ENODE *node);
AMODE * gen_pdiv(ENODE *node, int size);
AMODE * gen_pmul(ENODE *node, int size);
AMODE    *gen_mul(ENODE *node, int op, int fop, 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 fop, int size);
AMODE    *gen_aslogic(ENODE *node, int novalue, int op, int op2, int size ) ; /* PROTOTYPE */
AMODE *gen_asshift(ENODE *node, int novalue, int op, int div, int size);
AMODE    *gen_asmul(ENODE *node, int novalue, int op, int fop, int size);
AMODE    *gen_asmodiv(ENODE *node, int novalue,int op, int fop, int size, int modflag);
void mov1(AMODE *src, AMODE *dst, int size);
void mov2(AMODE *src, AMODE *dst, int size1,int size2);
void mov3(AMODE *src, AMODE *dst, int size1,int size2,int size3) ;
AMODE *amode_moveblock(AMODE *ap1, AMODE *ap2, int size);
AMODE *gen_moveblock(ENODE *node)      ;
int count_regs(AMODE *ap1, AMODE *ap2);
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 fop, int size);
int push_param(ENODE *ep,int size);
int push_stackblock(ENODE *ep);
int     gen_parms(ENODE *plist,int size);
AMODE *inlinecall(ENODE *node);
AMODE    *gen_fcall(ENODE *node,int novalue);
AMODE    *gen_repcons(ENODE *node);
AMODE    *gen_pfcall(ENODE *node,int size);
AMODE    *gen_expr(ENODE *node, int novalue, int adronly, int size);
AMODE	   *gen_void(ENODE *node);
int     natural_size(ENODE *node);
AMODE *gen_relat(ENODE *node);
AMODE * gen_compare(ENODE *node, int btype1, int btype2, int btype3, int btype4, int babst, int fbtype1, int fbtype2, int label);
void truejp(ENODE *node, int label);
void falsejp(ENODE *node, int label);