From de620e1fd5d85bfb1bb51dc30f6683db54ab5ad2 Mon Sep 17 00:00:00 2001 From: ceriel Date: Wed, 13 Nov 1991 16:53:49 +0000 Subject: [PATCH] Added --- fcc/.distr | 3 + fcc/Action | 6 + fcc/cemcom/.distr | 4 + fcc/cemcom/Parameters.sun3 | 151 +++++++++ fcc/cemcom/Parameters.vax4 | 151 +++++++++ fcc/cemcom/proto.main | 64 ++++ fcc/cemcom/proto.make | 274 ++++++++++++++++ fcc/driver/.distr | 3 + fcc/driver/fcc.1 | 148 +++++++++ fcc/driver/fcc.c | 640 +++++++++++++++++++++++++++++++++++++ fcc/driver/proto.make | 38 +++ mach/vax4/libce/.distr | 2 + mach/vax4/libce/proto.make | 32 ++ mach/vax4/libce/sys.s | 6 + 14 files changed, 1522 insertions(+) create mode 100644 fcc/.distr create mode 100644 fcc/Action create mode 100644 fcc/cemcom/.distr create mode 100644 fcc/cemcom/Parameters.sun3 create mode 100644 fcc/cemcom/Parameters.vax4 create mode 100644 fcc/cemcom/proto.main create mode 100644 fcc/cemcom/proto.make create mode 100644 fcc/driver/.distr create mode 100644 fcc/driver/fcc.1 create mode 100644 fcc/driver/fcc.c create mode 100644 fcc/driver/proto.make create mode 100644 mach/vax4/libce/.distr create mode 100644 mach/vax4/libce/proto.make create mode 100644 mach/vax4/libce/sys.s diff --git a/fcc/.distr b/fcc/.distr new file mode 100644 index 000000000..04696d0c4 --- /dev/null +++ b/fcc/.distr @@ -0,0 +1,3 @@ +Action +cemcom +driver diff --git a/fcc/Action b/fcc/Action new file mode 100644 index 000000000..3f4edc99b --- /dev/null +++ b/fcc/Action @@ -0,0 +1,6 @@ +name "Fast cc-compatible C compiler" +dir cemcom +end +name "Driver for fast cc-compatible C compiler" +dir driver +end diff --git a/fcc/cemcom/.distr b/fcc/cemcom/.distr new file mode 100644 index 000000000..7f00154bd --- /dev/null +++ b/fcc/cemcom/.distr @@ -0,0 +1,4 @@ +Parameters.sun3 +Parameters.vax4 +proto.main +proto.make diff --git a/fcc/cemcom/Parameters.sun3 b/fcc/cemcom/Parameters.sun3 new file mode 100644 index 000000000..88bfdf501 --- /dev/null +++ b/fcc/cemcom/Parameters.sun3 @@ -0,0 +1,151 @@ +!File: lint.h +#undef LINT 1 /* if defined, 'lint' is produced */ + + +!File: pathlength.h +#define PATHLENGTH 1024 /* max. length of path to file */ + + +!File: errout.h +#define ERROUT STDERR /* file pointer for writing messages */ +#define ERR_SHADOW 5 /* a syntax error overshadows error messages + until ERR_SHADOW symbols have been + accepted without syntax error */ + + +!File: idfsize.h +#define IDFSIZE 64 /* maximum significant length of an identifier */ + + +!File: numsize.h +#define NUMSIZE 256 /* maximum length of a numeric constant */ + + +!File: nparams.h +#define NPARAMS 32 /* maximum number of parameters of macros */ + + +!File: ifdepth.h +#define IFDEPTH 256 /* maximum number of nested if-constructions */ + + +!File: density.h +#define DENSITY 3 /* see switch.[ch] for an explanation */ + + +!File: lapbuf.h +#define LAPBUF 4096 /* size of macro actual parameter buffer */ + + +!File: strsize.h +#define ISTRSIZE 32 /* minimum number of bytes allocated for + storing a string */ +#define RSTRSIZE 16 /* step size in enlarging the memory for + the storage of a string */ + + +!File: target_sizes.h +#define MAXSIZE 8 /* the maximum of the SZ_* constants */ + +/* target machine sizes */ +#define SZ_CHAR (arith)1 +#define SZ_SHORT (arith)2 +#define SZ_WORD (arith)4 +#define SZ_INT (arith)4 +#define SZ_LONG (arith)4 +#ifndef NOFLOAT +#define SZ_FLOAT (arith)4 +#define SZ_DOUBLE (arith)8 +#endif NOFLOAT +#define SZ_POINTER (arith)4 + +/* target machine alignment requirements */ +#define AL_CHAR 1 +#define AL_SHORT SZ_SHORT +#define AL_WORD 2 +#define AL_INT 2 +#define AL_LONG 2 +#ifndef NOFLOAT +#define AL_FLOAT 2 +#define AL_DOUBLE 2 +#endif NOFLOAT +#define AL_POINTER 2 +#define AL_STRUCT 2 +#define AL_UNION 2 + + +!File: botch_free.h +#undef BOTCH_FREE 1 /* when defined, botch freed memory, as a check */ + + +!File: dataflow.h +#undef DATAFLOW 1 /* produce some compile-time xref */ + + +!File: debug.h +#undef DEBUG 1 /* perform various self-tests */ + + +!File: use_tmp.h +#define PREPEND_SCOPES 1 /* collect exa, exp, ina and inp commands + and if USE_TMP is defined let them + precede the rest of the generated + compact code */ +#undef USE_TMP 1 /* use C_insertpart, C_endpart mechanism + to generate EM-code in the order needed + for the code-generators. If not defined, + the old-style peephole optimizer is + needed. */ + + +!File: parbufsize.h +#define PARBUFSIZE 1024 + + +!File: textsize.h +#define ITEXTSIZE 32 /* 1st piece of memory for repl. text */ +#define RTEXTSIZE 16 /* stepsize for enlarging repl.text */ + + +!File: inputtype.h +#define INP_READ_IN_ONE 1 /* read input file in one */ + + +!File: nopp.h +#undef NOPP 1 /* if NOT defined, use built-int preprocessor */ + + +!File: nobitfield.h +#undef NOBITFIELD 1 /* if NOT defined, implement bitfields */ + + +!File: spec_arith.h +/* describes internal compiler arithmetics */ +#undef SPECIAL_ARITHMETICS /* something different from native long */ + + +!File: static.h +#define GSTATIC /* for large global "static" arrays */ + + +!File: nofloat.h +#undef NOFLOAT 1 /* if NOT defined, floats are implemented */ + + +!File: noRoption.h +#undef NOROPTION 1 /* if NOT defined, R option is implemented */ + + +!File: nocross.h +#define NOCROSS 1 /* if NOT defined, cross compiler */ + + +!File: regcount.h +#undef REGCOUNT 1 /* count occurrences for register messages */ + + +!File: dbsymtab.h +#define DBSYMTAB 1 /* ability to produce symbol table for debugger +*/ + + diff --git a/fcc/cemcom/Parameters.vax4 b/fcc/cemcom/Parameters.vax4 new file mode 100644 index 000000000..75b014160 --- /dev/null +++ b/fcc/cemcom/Parameters.vax4 @@ -0,0 +1,151 @@ +!File: lint.h +#undef LINT 1 /* if defined, 'lint' is produced */ + + +!File: pathlength.h +#define PATHLENGTH 1024 /* max. length of path to file */ + + +!File: errout.h +#define ERROUT STDERR /* file pointer for writing messages */ +#define ERR_SHADOW 5 /* a syntax error overshadows error messages + until ERR_SHADOW symbols have been + accepted without syntax error */ + + +!File: idfsize.h +#define IDFSIZE 64 /* maximum significant length of an identifier */ + + +!File: numsize.h +#define NUMSIZE 256 /* maximum length of a numeric constant */ + + +!File: nparams.h +#define NPARAMS 32 /* maximum number of parameters of macros */ + + +!File: ifdepth.h +#define IFDEPTH 256 /* maximum number of nested if-constructions */ + + +!File: density.h +#define DENSITY 3 /* see switch.[ch] for an explanation */ + + +!File: lapbuf.h +#define LAPBUF 4096 /* size of macro actual parameter buffer */ + + +!File: strsize.h +#define ISTRSIZE 32 /* minimum number of bytes allocated for + storing a string */ +#define RSTRSIZE 16 /* step size in enlarging the memory for + the storage of a string */ + + +!File: target_sizes.h +#define MAXSIZE 8 /* the maximum of the SZ_* constants */ + +/* target machine sizes */ +#define SZ_CHAR (arith)1 +#define SZ_SHORT (arith)2 +#define SZ_WORD (arith)4 +#define SZ_INT (arith)4 +#define SZ_LONG (arith)4 +#ifndef NOFLOAT +#define SZ_FLOAT (arith)4 +#define SZ_DOUBLE (arith)8 +#endif NOFLOAT +#define SZ_POINTER (arith)4 + +/* target machine alignment requirements */ +#define AL_CHAR 1 +#define AL_SHORT SZ_SHORT +#define AL_WORD SZ_WORD +#define AL_INT SZ_WORD +#define AL_LONG SZ_WORD +#ifndef NOFLOAT +#define AL_FLOAT SZ_WORD +#define AL_DOUBLE SZ_WORD +#endif NOFLOAT +#define AL_POINTER SZ_WORD +#define AL_STRUCT 1 +#define AL_UNION 1 + + +!File: botch_free.h +#undef BOTCH_FREE 1 /* when defined, botch freed memory, as a check */ + + +!File: dataflow.h +#undef DATAFLOW 1 /* produce some compile-time xref */ + + +!File: debug.h +#undef DEBUG 1 /* perform various self-tests */ + + +!File: use_tmp.h +#define PREPEND_SCOPES 1 /* collect exa, exp, ina and inp commands + and if USE_TMP is defined let them + precede the rest of the generated + compact code */ +#undef USE_TMP 1 /* use C_insertpart, C_endpart mechanism + to generate EM-code in the order needed + for the code-generators. If not defined, + the old-style peephole optimizer is + needed. */ + + +!File: parbufsize.h +#define PARBUFSIZE 1024 + + +!File: textsize.h +#define ITEXTSIZE 32 /* 1st piece of memory for repl. text */ +#define RTEXTSIZE 16 /* stepsize for enlarging repl.text */ + + +!File: inputtype.h +#define INP_READ_IN_ONE 1 /* read input file in one */ + + +!File: nopp.h +#undef NOPP 1 /* if NOT defined, use built-int preprocessor */ + + +!File: nobitfield.h +#undef NOBITFIELD 1 /* if NOT defined, implement bitfields */ + + +!File: spec_arith.h +/* describes internal compiler arithmetics */ +#undef SPECIAL_ARITHMETICS /* something different from native long */ + + +!File: static.h +#define GSTATIC /* for large global "static" arrays */ + + +!File: nofloat.h +#undef NOFLOAT 1 /* if NOT defined, floats are implemented */ + + +!File: noRoption.h +#undef NOROPTION 1 /* if NOT defined, R option is implemented */ + + +!File: nocross.h +#define NOCROSS 1 /* if NOT defined, cross compiler */ + + +!File: regcount.h +#undef REGCOUNT 1 /* count occurrences for register messages */ + + +!File: dbsymtab.h +#define DBSYMTAB 1 /* ability to produce symbol table for debugger +*/ + + diff --git a/fcc/cemcom/proto.main b/fcc/cemcom/proto.main new file mode 100644 index 000000000..e2291d420 --- /dev/null +++ b/fcc/cemcom/proto.main @@ -0,0 +1,64 @@ +# $Header$ + +# C compilation part. Not to be called directly. +# Instead, it is to be called by the Makefile. +# SRC_DIR, UTIL_HOME, TARGET_HOME, CC, COPTIONS, LINT, LINTOPTIONS, LDOPTIONS, +# CC_AND_MKDEP, SUF, LIBSUF, CE should be set here. + +#PARAMS do not remove this line! + +MDIR = $(TARGET_HOME)/modules +LIBDIR = $(MDIR)/lib +LINTLIBDIR = $(UTIL_HOME)/modules/lib + +MALLOC = $(LIBDIR)/malloc.$(SUF) + +EMLIB = $(LIBDIR)/libem_mesO.$(LIBSUF) \ + $(LIBDIR)/libCEopt.$(LIBSUF) \ + $(CE) \ + $(TARGET_HOME)/lib.bin/em_data.$(LIBSUF) \ + $(LIBDIR)/libobject.$(LIBSUF) + +MODLIB = $(LIBDIR)/libinput.$(LIBSUF) \ + $(LIBDIR)/libassert.$(LIBSUF) \ + $(LIBDIR)/liballoc.$(LIBSUF) \ + $(MALLOC) \ + $(LIBDIR)/libflt.$(LIBSUF) \ + $(LIBDIR)/libprint.$(LIBSUF) \ + $(LIBDIR)/libstring.$(LIBSUF) \ + $(LIBDIR)/libsystem.$(LIBSUF) + +LIBS = $(EMLIB) $(MODLIB) + +LINTLIBS = $(LINTLIBDIR)/$(LINTPREF)em_mes.$(LINTSUF) \ + $(LINTLIBDIR)/$(LINTPREF)emk.$(LINTSUF) \ + $(LINTLIBDIR)/$(LINTPREF)input.$(LINTSUF) \ + $(LINTLIBDIR)/$(LINTPREF)assert.$(LINTSUF) \ + $(LINTLIBDIR)/$(LINTPREF)alloc.$(LINTSUF) \ + $(LINTLIBDIR)/$(LINTPREF)flt.$(LINTSUF) \ + $(LINTLIBDIR)/$(LINTPREF)print.$(LINTSUF) \ + $(LINTLIBDIR)/$(LINTPREF)string.$(LINTSUF) \ + $(LINTLIBDIR)/$(LINTPREF)system.$(LINTSUF) + +PROFILE = +INCLUDES = -I. -I$(SRC_DIR) -I$(TARGET_HOME)/modules/h -I$(TARGET_HOME)/h -I$(TARGET_HOME)/modules/pkg +CFLAGS = $(PROFILE) $(INCLUDES) $(COPTIONS) +LINTFLAGS = $(INCLUDES) $(LINTOPTIONS) +LDFLAGS = $(PROFILE) $(LDOPTIONS) + +# C_SRC and OBJ should be set here. +#LISTS do not remove this line! + +all: main + +clean: + rm -f *.$(SUF) main + +lint: + $(LINT) $(LINTFLAGS) $(C_SRC) $(LINTLIBS) + +main: $(OBJ) + $(CC) $(LDFLAGS) $(OBJ) $(LIBS) -o main + +# do not remove the next line; it is used for generating dependencies +#DEPENDENCIES diff --git a/fcc/cemcom/proto.make b/fcc/cemcom/proto.make new file mode 100644 index 000000000..818cfdcdc --- /dev/null +++ b/fcc/cemcom/proto.make @@ -0,0 +1,274 @@ +# $Header$ + +# make C compiler + +#PARAMS do not remove this line! + +UTIL_BIN = \ + $(UTIL_HOME)/bin +SRC_DIR = \ + $(SRC_HOME)/lang/cem/cemcom +FSRC_DIR = \ + $(SRC_HOME)/fcc/cemcom + +TABGEN= $(UTIL_BIN)/tabgen +LLGEN = $(UTIL_BIN)/LLgen +LLGENOPTIONS = \ + -v + +SRC_G = $(SRC_DIR)/program.g $(SRC_DIR)/declar.g \ + $(SRC_DIR)/expression.g $(SRC_DIR)/statement.g $(SRC_DIR)/ival.g +GEN_G = tokenfile.g +GFILES= $(GEN_G) $(SRC_G) + +SRC_C = \ + $(SRC_DIR)/Version.c \ + $(SRC_DIR)/LLlex.c \ + $(SRC_DIR)/LLmessage.c \ + $(SRC_DIR)/arith.c \ + $(SRC_DIR)/asm.c \ + $(SRC_DIR)/blocks.c \ + $(SRC_DIR)/ch7.c \ + $(SRC_DIR)/ch7bin.c \ + $(SRC_DIR)/ch7mon.c \ + $(SRC_DIR)/code.c \ + $(SRC_DIR)/conversion.c \ + $(SRC_DIR)/cstoper.c \ + $(SRC_DIR)/dataflow.c \ + $(SRC_DIR)/declarator.c \ + $(SRC_DIR)/decspecs.c \ + $(SRC_DIR)/domacro.c \ + $(SRC_DIR)/dumpidf.c \ + $(SRC_DIR)/error.c \ + $(SRC_DIR)/eval.c \ + $(SRC_DIR)/expr.c \ + $(SRC_DIR)/field.c \ + $(SRC_DIR)/idf.c \ + $(SRC_DIR)/init.c \ + $(SRC_DIR)/input.c \ + $(SRC_DIR)/l_comment.c \ + $(SRC_DIR)/l_ev_ord.c \ + $(SRC_DIR)/l_lint.c \ + $(SRC_DIR)/l_misc.c \ + $(SRC_DIR)/l_outdef.c \ + $(SRC_DIR)/l_states.c \ + $(SRC_DIR)/label.c \ + $(SRC_DIR)/main.c \ + $(SRC_DIR)/options.c \ + $(SRC_DIR)/replace.c \ + $(SRC_DIR)/scan.c \ + $(SRC_DIR)/skip.c \ + $(SRC_DIR)/stack.c \ + $(SRC_DIR)/struct.c \ + $(SRC_DIR)/switch.c \ + $(SRC_DIR)/tokenname.c \ + $(SRC_DIR)/type.c \ + $(SRC_DIR)/util.c \ + $(SRC_DIR)/stab.c + +GEN_C = tokenfile.c program.c declar.c expression.c statement.c ival.c \ + symbol2str.c char.c Lpars.c next.c +CFILES= $(SRC_C) $(GEN_C) + +SRC_H = \ + $(SRC_DIR)/LLlex.h \ + $(SRC_DIR)/align.h \ + $(SRC_DIR)/arith.h \ + $(SRC_DIR)/assert.h \ + $(SRC_DIR)/atw.h \ + $(SRC_DIR)/class.h \ + $(SRC_DIR)/decspecs.h \ + $(SRC_DIR)/file_info.h \ + $(SRC_DIR)/input.h \ + $(SRC_DIR)/interface.h \ + $(SRC_DIR)/l_class.h \ + $(SRC_DIR)/l_comment.h \ + $(SRC_DIR)/l_em.h \ + $(SRC_DIR)/l_lint.h \ + $(SRC_DIR)/label.h \ + $(SRC_DIR)/level.h \ + $(SRC_DIR)/mes.h \ + $(SRC_DIR)/sizes.h \ + $(SRC_DIR)/specials.h \ + $(SRC_DIR)/tokenname.h + +GEN_H = botch_free.h dataflow.h debug.h density.h errout.h \ + idfsize.h ifdepth.h inputtype.h lint.h \ + nobitfield.h nopp.h nocross.h \ + nparams.h numsize.h parbufsize.h pathlength.h Lpars.h \ + strsize.h target_sizes.h textsize.h use_tmp.h spec_arith.h static.h \ + regcount.h \ + code.h declar.h decspecs.h def.h expr.h field.h estack.h util.h \ + idf.h macro.h stmt.h struct.h switch.h type.h l_brace.h l_state.h \ + l_outdef.h stack.h lapbuf.h noRoption.h nofloat.h dbsymtab.h + +HFILES= $(GEN_H) $(SRC_H) + +NEXTFILES = \ + $(SRC_DIR)/code.str \ + $(SRC_DIR)/declar.str \ + $(SRC_DIR)/decspecs.str \ + $(SRC_DIR)/def.str \ + $(SRC_DIR)/expr.str \ + $(SRC_DIR)/field.str \ + $(SRC_DIR)/estack.str \ + $(SRC_DIR)/util.str \ + $(SRC_DIR)/idf.str \ + $(SRC_DIR)/macro.str \ + $(SRC_DIR)/stack.str \ + $(SRC_DIR)/stmt.str \ + $(SRC_DIR)/struct.str \ + $(SRC_DIR)/switch.str \ + $(SRC_DIR)/type.str \ + $(SRC_DIR)/l_brace.str \ + $(SRC_DIR)/l_state.str \ + $(SRC_DIR)/l_outdef.str + +all: make.main + make -f make.main main + +install: all + cp main $(TARGET_HOME)/lib.bin/c_cccompat + +cmp: all + -cmp main $(TARGET_HOME)/lib.bin/c_cccompat + +opr: + make pr | opr + +pr: + @pr $(FSRC_DIR)/proto.make $(FSRC_DIR)/proto.main \ + $(FSRC_DIR)/Parameters.vax4 $(FSRC_DIR)/Parameters.sun3 + +lint: make.main + make -f make.main lint + +Cfiles: hfiles LLfiles $(GEN_C) $(GEN_H) Makefile + echo $(CFILES) | tr ' ' '\012' > Cfiles + echo $(HFILES) | tr ' ' '\012' >> Cfiles + +resolved: Cfiles + CC="$(CC)" UTIL_HOME="$(UTIL_HOME)" do_resolve `cat Cfiles` > Cfiles.new + -if cmp -s Cfiles Cfiles.new ; then rm -f Cfiles.new ; else mv Cfiles.new Cfiles ; fi + touch resolved + +# there is no file called "dependencies"; we want dependencies checked +# every time. This means that make.main is made every time. Oh well ... +# it does not take much time. +dependencies: resolved + do_deps `grep '.c$$' Cfiles` + +make.main: dependencies make_macros lists $(FSRC_DIR)/proto.main + sed -e '/^#DEPENDENCIES/,$$d' -e '/^#PARAMS/r make_macros' -e '/^#LISTS/r lists' $(FSRC_DIR)/proto.main > make.main + echo '#DEPENDENCIES' >> make.main + cat *.dep >> make.main + +make_macros: Makefile + echo 'SRC_DIR=$(SRC_DIR)' > make_macros + echo 'UTIL_HOME=$(UTIL_HOME)' >> make_macros + echo 'TARGET_HOME=$(TARGET_HOME)' >> make_macros + echo 'CC=$(CC)' >> make_macros + echo 'COPTIONS=$(COPTIONS) -DPEEPHOLE' >> make_macros + echo 'LDOPTIONS=$(LDOPTIONS)' >> make_macros + echo 'LINT=$(LINT)' >> make_macros + echo 'LINTOPTIONS=$(LINTOPTIONS)' >> make_macros + echo 'SUF=$(SUF)' >> make_macros + echo 'LIBSUF=$(LIBSUF)' >> make_macros + echo 'CC_AND_MKDEP=$(CC_AND_MKDEP)' >> make_macros + if [ $(MACH) = m68020 ] ; then \ + echo 'CE=$(TARGET_HOME)/lib.bin/sun3/ce.$(LIBSUF) $(TARGET_HOME)/lib.bin/sun3/back.$(LIBSUF)' >> make_macros ; \ + else \ + echo 'CE=$(TARGET_HOME)/lib.bin/vax4/ce.$(LIBSUF) $(TARGET_HOME)/lib.bin/vax4/back_vax.$(LIBSUF)' >> make_macros ; \ + fi + +lists: Cfiles + echo "C_SRC = \\" > lists + echo $(CFILES) >> lists + echo "OBJ = \\" >> lists + echo $(CFILES) | sed -e 's#[^ ]*/##g' -e 's/\.c/.$$(SUF)/g' >> lists + +clean: + -make -f make.main clean + rm -f $(GEN_C) $(GEN_G) $(GEN_H) hfiles LLfiles Cfiles LL.output + rm -f resolved *.dep lists make.main make_macros + +LLfiles: $(GFILES) + $(LLGEN) $(LLGENOPTIONS) $(GFILES) + @touch LLfiles + +hfiles: Parameters $(SRC_DIR)/make.hfiles + $(SRC_DIR)/make.hfiles Parameters + touch hfiles + +Parameters: $(FSRC_DIR)/Parameters.sun3 $(FSRC_DIR)/Parameters.vax4 + if [ $(MACH) = m68020 ] ; then \ + cp $(FSRC_DIR)/Parameters.sun3 Parameters ; \ + else \ + cp $(FSRC_DIR)/Parameters.vax4 Parameters ; \ + fi + +tokenfile.g: $(SRC_DIR)/tokenname.c $(SRC_DIR)/make.tokfile + $(SRC_DIR)/make.tokfile <$(SRC_DIR)/tokenname.c >tokenfile.g + +symbol2str.c: $(SRC_DIR)/tokenname.c $(SRC_DIR)/make.tokcase + $(SRC_DIR)/make.tokcase <$(SRC_DIR)/tokenname.c >symbol2str.c + +code.h: $(SRC_DIR)/code.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/code.str > code.h + +declar.h: $(SRC_DIR)/declar.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/declar.str > declar.h + +def.h: $(SRC_DIR)/def.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/def.str > def.h + +expr.h: $(SRC_DIR)/expr.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/expr.str > expr.h + +field.h: $(SRC_DIR)/field.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/field.str > field.h + +estack.h: $(SRC_DIR)/estack.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/estack.str > estack.h + +util.h: $(SRC_DIR)/util.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/util.str > util.h + +decspecs.h: $(SRC_DIR)/decspecs.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/decspecs.str > decspecs.h + +idf.h: $(SRC_DIR)/idf.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/idf.str > idf.h + +macro.h: $(SRC_DIR)/macro.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/macro.str > macro.h + +stack.h: $(SRC_DIR)/stack.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/stack.str > stack.h + +stmt.h: $(SRC_DIR)/stmt.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/stmt.str > stmt.h + +struct.h: $(SRC_DIR)/struct.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/struct.str > struct.h + +switch.h: $(SRC_DIR)/switch.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/switch.str > switch.h + +type.h: $(SRC_DIR)/type.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/type.str > type.h + +l_brace.h: $(SRC_DIR)/l_brace.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/l_brace.str > l_brace.h + +l_state.h: $(SRC_DIR)/l_state.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/l_state.str > l_state.h + +l_outdef.h: $(SRC_DIR)/l_outdef.str $(SRC_DIR)/make.allocd + $(SRC_DIR)/make.allocd < $(SRC_DIR)/l_outdef.str > l_outdef.h + +next.c: $(NEXTFILES) $(SRC_DIR)/make.next + $(SRC_DIR)/make.next $(NEXTFILES) > next.c + +char.c: $(SRC_DIR)/char.tab + $(TABGEN) -f$(SRC_DIR)/char.tab >char.c diff --git a/fcc/driver/.distr b/fcc/driver/.distr new file mode 100644 index 000000000..ebc669f71 --- /dev/null +++ b/fcc/driver/.distr @@ -0,0 +1,3 @@ +fcc.1 +fcc.c +proto.make diff --git a/fcc/driver/fcc.1 b/fcc/driver/fcc.1 new file mode 100644 index 000000000..acd05b758 --- /dev/null +++ b/fcc/driver/fcc.1 @@ -0,0 +1,148 @@ +.TH FCC 1 +.SH NAME +fcc \- fast CC-compatible C compiler +.SH SYNOPSIS +.B fcc +[ +.B \-c +] +[ +.B \-v +] +[ +.B \-vn +] +[ \fB\-D\fIname\fR ] +[ \fB\-D\fIname\fB=\fIdef\fR ] +[ +.BI \-I pathname +] +[ +.B \-w +] +[ +.B \-o +.I outfile +] +[ +.B \-R +] +[ +.BI \-U name +] +[ +.BI -M compiler +] +.I sourcefile ... +.SH DESCRIPTION +.LP +.I Fcc +is a fast +.B C +compiler. It translates +.B C +programs +into cc(1)-compatible relocatable object modules, and does so in one pass. +Then, if the \fB\-c\fP flag is not given, +.I fcc +offers the object modules to a link-editor, +to create an executable binary. +.LP +.I Fcc +accepts several types of filename arguments. Files with +names ending in +.B .c +are taken to be +.B C +source programs. +They are compiled, and the resulting object module is placed in the current +directory. +The object module is named after its source file, the suffix +.B .o +replacing +.BR .c +in the name of the object. +.LP +Other arguments refer to loader options, +object modules, or object libraries. +Unless the +.B \-c +flag is given, these modules and libraries, together with the results of any +specified compilations, are passed (in the order given) to the +link-editor to produce +an output file named +.IR a.out . +You can specify a name for the executable by using the +.B \-o +option. +.SH OPTIONS +.LP +The \fB\-l\fIlib\fR, \fB\-n\fP, \fB\-N\fP, +\fB\-r\fP, \fB\-s\fP, \fB\-S\fP, and \fB\-u\fP options are +passed to the link-editor program. +The \fB\-u\fP option takes an extra argument. +.IP \fB\-c\fP +.br +Suppress the loading phase of the compilation, and force an object module to +be produced, even if only one program is compiled. +A single object module can be named explicitly using the +.B \-o +option. +.IP \fB\-D\fIname\fR\fB=\fIdef\fR +Define a symbol +.I name +to the +preprocessor, as if by "#define". +.IP \fB\-D\fIname\fR +.br +same as \fB\-D\fIname\fB=1\fR. +.IP \fB\-I\fIpathname\fR +.br +Add +.I pathname +to the list of directories in which to search for +.B #include +files with filenames not beginning with slash. +The compiler first searches for +.B #include +files in the directory containing +.I sourcefile, +then in directories in +.B \-I +options, and finally, in +.I /usr/include. +.IP "\fB\-o \fIoutput\fR" +Name the final output file +.I output. +.IP \fB\-U\fIname\fR +.br +Remove any initial definition of +.I name. +.IP \fB\-v\fP +.br +Verbose. Print the commands as they are executed. +.IP \fB\-vn\fP +.br +Verbose, no execute. Only print the commands, do not execute them. +.IP \fB\-w\fP +suppress warning messages. +.IP \fB\-R\fP +.br +test for more compatibility with Kernighan & Ritchie C [1]. +.IP \fB\-M\fIcompiler\fR +.br +use \fIcompiler\fR as C-2 compiler instead of the default. +.LP +Object modules produced by cc(1) and +.I fcc +can be freely mixed, as long as the link-editor is called through +.I fcc. +.SH "SEE ALSO" +.IP [1] +B.W. Kernighan, D. Ritchie, "\fIThe C programming Language\fP", Prentice-Hall Inc., 1978 +.IP [2] +E.H. Baalbergen, "\fIThe ACK CEM compiler\fP". +.IP [3] +cc(1) unix manual page. +.SH DIAGNOSTICS +Diagnostics are intended to be self-explanatory. diff --git a/fcc/driver/fcc.c b/fcc/driver/fcc.c new file mode 100644 index 000000000..6421f9067 --- /dev/null +++ b/fcc/driver/fcc.c @@ -0,0 +1,640 @@ +/* fcc + Driver for fast cc-compatible ACK C compiler. + + Derived from the C compiler driver from Minix. + + Compile this file with + cc -O -I/config driver.c + Install the resulting binaries in the EM bin directory. + Suggested name: fcc +*/ + +#ifdef sun3 +#define MACHNAME "m68020" +#define SYSNAME "sun3" +#endif + +#ifdef vax4 +#define MACHNAME "vax4" +#define SYSNAME "vax4" +#endif + +#include +#include +#include +#include +#include + +/* + Version producing cc-compatible .o files in one pass. +*/ +#define MAXARGC 256 /* maximum number of arguments allowed in a list */ +#define USTR_SIZE 128 /* maximum length of string variable */ + +typedef char USTRING[USTR_SIZE]; + +struct arglist { + int al_argc; + char *al_argv[MAXARGC]; +}; + +#define CPP_NAME "$H/lib.bin/cpp" +#define LD_NAME "/bin/ld" +#define AS_NAME "/bin/as" +#define SHELL "/bin/sh" + +char *CPP; +char *COMP; + +int kids = -1; +int ecount = 0; + +struct arglist CPP_FLAGS = { + 7, + { + "-Dunix", + "-D_EM_WSIZE=4", + "-D_EM_PSIZE=4", + "-D_EM_SSIZE=2", + "-D_EM_LSIZE=4", + "-D_EM_FSIZE=4", + "-D_EM_DSIZE=8", + } +}; + +struct arglist LD_HEAD = { +#ifdef sun3 + 8, + { + "-dc", + "-dp", + "-e", + "start", + "-X", + "-L/usr/lib/fsoft", + "/usr/lib/crt0.o", + "/usr/lib/Fcrt1.o" + } +#endif +#ifdef vax4 + 2, + { + "-X", + "/lib/crt0.o" + } +#endif +}; + +struct arglist LD_TAIL = { + 2, + { + "$H/lib/$S/tail_ext", + "-lc" + } +}; + +struct arglist LD_FLAGS; + +struct arglist COMP_FLAGS; + +char *o_FILE = "a.out"; /* default name for executable file */ + +#define remove(str) ((noexec || unlink(str)), (str)[0] = '\0') +#define cleanup(str) (str && str[0] && remove(str)) +#define init(al) ((al)->al_argc = 1) + +char ProgCall[128]; + +struct arglist SRCFILES; +struct arglist LDFILES; + +int RET_CODE = 0; + +struct arglist CALL_VEC; + +int o_flag = 0; +int c_flag = 0; +int v_flag = 0; +int O_flag = 0; + +char *mkstr(); +char *malloc(); +char *alloc(); +char *extension(); +char *expand_string(); + +USTRING ofile; +USTRING BASE; +USTRING tmp_file; + +int noexec = 0; + +extern char *strcat(), *strcpy(), *mktemp(), *strchr(); + +trapcc(sig) + int sig; +{ + signal(sig, SIG_IGN); + if (kids != -1) kill(kids, sig); + cleanup(ofile); + cleanup(tmp_file); + exit(1); +} + +#define lang_suffix() "c" +#define comp_name() "$H/lib.bin/c_cccompat" + +int +lang_opt(str) + char *str; +{ + switch(str[1]) { + case '-': /* debug options */ + case 'R': /* strict K&R */ + case 'w': /* disable warnings */ + append(&COMP_FLAGS, str); + return 1; + } + return 0; +} + +main(argc, argv) + char *argv[]; +{ + char *str; + char **argvec; + int count; + char *ext; + register struct arglist *call = &CALL_VEC; + char *file; + char *ldfile; + int compile_cnt = 0; + + setbuf(stdout, (char *) 0); + basename(*argv++,ProgCall); + + COMP = expand_string(comp_name()); + CPP = expand_string(CPP_NAME); + +#ifdef vax4 + append(&CPP_FLAGS, "-Dvax"); +#endif +#ifdef sun3 + append(&CPP_FLAGS, "-Dsun"); + append(&CPP_FLAGS, "-Dmc68020"); + append(&CPP_FLAGS, "-Dmc68000"); +#endif + + if (signal(SIGHUP, SIG_IGN) != SIG_IGN) + signal(SIGHUP, trapcc); + if (signal(SIGINT, SIG_IGN) != SIG_IGN) + signal(SIGINT, trapcc); + if (signal(SIGQUIT, SIG_IGN) != SIG_IGN) + signal(SIGQUIT, trapcc); + while (--argc > 0) { + if (*(str = *argv++) != '-') { + append(&SRCFILES, str); + continue; + } + + if (lang_opt(str)) { + } + else switch (str[1]) { + + case 'c': /* stop after producing .o files */ + c_flag = 1; + break; + case 'D': /* preprocessor #define */ + case 'U': /* preprocessor #undef */ + append(&CPP_FLAGS, str); + break; + case 'I': /* include directory */ + append(&CPP_FLAGS, str); + break; + case 'g': /* debugger support */ + append(&COMP_FLAGS, str); + break; + case 'o': /* target file */ + if (argc-- >= 0) { + o_flag = 1; + o_FILE = *argv++; + ext = extension(o_FILE); + if (ext != o_FILE && ! strcmp(ext, lang_suffix()) + ) { + error("-o would overwrite %s", o_FILE); + } + } + break; + case 'u': /* mark identifier as undefined */ + append(&LD_FLAGS, str); + if (argc-- >= 0) + append(&LD_FLAGS, *argv++); + break; + case 'O': /* use built in peephole optimizer */ + O_flag = 1; + break; + case 'v': /* verbose */ + v_flag++; + if (str[2] == 'n') + noexec = 1; + break; + case 'l': /* library file */ + append(&SRCFILES, str); + break; + case 't': /* -target? */ + if (! strcmp(str, "-target")) { + if (argc-- >= 0) argv++; + break; + } + warning("%s flag ignored", str); + break; + case 'M': /* use other compiler (for testing) */ + strcpy(COMP, str+2); + break; + case 's': /* strip, -sun3? */ + if (! strcmp(str, "-sun3")) { + break; + } + /* fall through */ + case 'n': /* text not read-only */ + case 'N': /* text read-only */ + case 'r': /* relocation produced */ + case 'S': /* strip, but leave locals and globals */ + if (str[2] == '\0') { + append(&LD_FLAGS, str); + break; + } + /* fall through */ + default: + warning("%s flag ignored", str); + break; + } + } + + if (ecount) exit(1); + + count = SRCFILES.al_argc; + argvec = &(SRCFILES.al_argv[0]); + while (count-- > 0) { + ext = extension(*argvec); + if (*argvec[0] != '-' && + ext != *argvec++ && (! strcmp(ext, lang_suffix()) + )) { + compile_cnt++; + } + } + + if (compile_cnt > 1 && c_flag && o_flag) { + warning("-o flag ignored"); + o_flag = 0; + } + + append(&COMP_FLAGS, "-L"); + count = SRCFILES.al_argc; + argvec = &(SRCFILES.al_argv[0]); + while (count-- > 0) { + register char *f; + basename(file = *argvec++, BASE); + + ext = extension(file); + + if (file[0] != '-' && + ext != file && (!strcmp(ext, lang_suffix()) + )) { + if (compile_cnt > 1) printf("%s\n", file); + + ldfile = c_flag ? ofile : alloc((unsigned)strlen(BASE)+3); + if ( + !strcmp(ext, "s") && + needsprep(file)) { + strcpy(tmp_file, TMP_DIR); + strcat(tmp_file, "/F_XXXXXX"); + mktemp(tmp_file); + init(call); + append(call, CPP); + concat(call, &CPP_FLAGS); + append(call, file); + if (runvec(call, tmp_file)) { + file = tmp_file; + } + else { + remove(tmp_file); + tmp_file[0] = '\0'; + continue; + } + } + init(call); + if (o_flag && c_flag) { + f = o_FILE; + } + else f = mkstr(ldfile, BASE, ".", "o", (char *)0); + if (strcmp(ext, "s")) { + append(call, COMP); + concat(call, &CPP_FLAGS); + concat(call, &COMP_FLAGS); + append(call, file); + append(call, f); + } + else { + append(call, AS_NAME); + append(call, "-o"); + append(call, f); +#ifdef sun3 + append(call, "-mc68020"); +#endif + append(call, file); + } + if (runvec(call, (char *) 0)) { + file = f; + } + else { + remove(f); + continue; + } + cleanup(tmp_file); + tmp_file[0] = '\0'; + } + + else if (file[0] != '-' && + strcmp(ext, "o") && strcmp(ext, "a")) { + warning("file with unknown suffix (%s) passed to the loader", ext); + } + + if (c_flag) + continue; + + append(&LDFILES, file); + } + + /* *.s to a.out */ + if (RET_CODE == 0 && LDFILES.al_argc > 0) { + init(call); + expand(&LD_HEAD); + expand(&LD_TAIL); + append(call, expand_string(LD_NAME)); + concat(call, &LD_FLAGS); + append(call, "-o"); + append(call, o_FILE); + concat(call, &LD_HEAD); + concat(call, &LDFILES); + concat(call, &LD_TAIL); + if (! runvec(call, (char *) 0)) { + exit(RET_CODE); + } + } + exit(RET_CODE); +} + +needsprep(name) + char *name; +{ + int file; + char fc; + + file = open(name,0); + if (file < 0) return 0; + if (read(file, &fc, 1) != 1) fc = 0; + close(file); + return fc == '#'; +} + +char * +alloc(u) + unsigned u; +{ + char *p = malloc(u); + + if (p == 0) + panic("no space"); + return p; +} + +char * +expand_string(s) + char *s; +{ + char buf[1024]; + register char *p = s; + register char *q = &buf[0]; + int expanded = 0; + + if (!p) return p; + while (*p) { + if (*p == '$') { + p++; + expanded = 1; + switch(*p++) { + case 'H': + strcpy(q, EM_DIR); + break; + case 'M': + strcpy(q, MACHNAME); + break; + case 'S': + strcpy(q, SYSNAME); + break; + default: + panic("internal error"); + break; + } + while (*q) q++; + } + else *q++ = *p++; + } + if (! expanded) return s; + *q++ = '\0'; + p = alloc((unsigned int) (q - buf)); + return strcpy(p, buf); +} + +append(al, arg) + register struct arglist *al; + char *arg; +{ + if (!arg || !*arg) return; + if (al->al_argc >= MAXARGC) + panic("argument list overflow"); + al->al_argv[(al->al_argc)++] = arg; +} + +expand(al) + register struct arglist *al; +{ + register int i = al->al_argc; + register char **p = &(al->al_argv[0]); + + while (i-- > 0) { + *p = expand_string(*p); + p++; + } +} + +concat(al1, al2) + struct arglist *al1, *al2; +{ + register i = al2->al_argc; + register char **p = &(al1->al_argv[al1->al_argc]); + register char **q = &(al2->al_argv[0]); + + if ((al1->al_argc += i) >= MAXARGC) + panic("argument list overflow"); + while (i-- > 0) { + *p++ = *q++; + } +} + +/*VARARGS*/ +char * +mkstr(va_alist) + va_dcl +{ + va_list ap; + char *dst; + + va_start(ap); + { + register char *p; + register char *q; + + dst = q = va_arg(ap, char *); + p = va_arg(ap, char *); + + while (p) { + while (*q++ = *p++); + q--; + p = va_arg(ap, char *); + } + } + va_end(ap); + + return dst; +} + +basename(str, dst) + char *str; + register char *dst; +{ + register char *p1 = str; + register char *p2 = p1; + + while (*p1) + if (*p1++ == '/') + p2 = p1; + p1--; + while (*p1 != '.' && p1 >= p2) p1--; + if (p1 >= p2) { + *p1 = '\0'; + while (*dst++ = *p2++); + *p1 = '.'; + } + else + while (*dst++ = *p2++); +} + +char * +extension(fn) + char *fn; +{ + register char *c = fn; + + while (*c++) ; + while (*--c != '.' && c >= fn) { } + if (c++ < fn || !*c) return fn; + return c; +} + +runvec(vec, outp) + struct arglist *vec; + char *outp; +{ + int pid, status; + + if (v_flag) { + pr_vec(vec); + putc('\n', stderr); + } + if ((pid = fork()) == 0) { /* start up the process */ + if (outp) { /* redirect standard output */ + close(1); + if (creat(outp, 0666) != 1) + panic("cannot create output file"); + } + ex_vec(vec); + } + if (pid == -1) + panic("no more processes"); + kids = pid; + wait(&status); + if (status) switch(status & 0177) { + case SIGHUP: + case SIGINT: + case SIGQUIT: + case SIGTERM: + case 0: + break; + default: + error("%s died with signal %d\n", vec->al_argv[1], status&0177); + } + kids = -1; + return status ? ((RET_CODE = 1), 0) : 1; +} + +/*VARARGS1*/ +error(str, s1, s2) + char *str, *s1, *s2; +{ + fprintf(stderr, "%s: ", ProgCall); + fprintf(stderr, str, s1, s2); + putc('\n', stderr); + ecount++; +} + +/*VARARGS1*/ +warning(str, s1, s2) + char *str, *s1, *s2; +{ + fprintf(stderr, "%s: (warning) ", ProgCall); + fprintf(stderr, str, s1, s2); + putc('\n', stderr); +} + +panic(str) + char *str; +{ + error(str); + trapcc(SIGINT); +} + +pr_vec(vec) + register struct arglist *vec; +{ + register char **ap = &vec->al_argv[1]; + + vec->al_argv[vec->al_argc] = 0; + fprintf(stderr, "%s", *ap); + while (*++ap) { + fprintf(stderr, " %s", *ap); + } +} + +extern int errno; + +ex_vec(vec) + register struct arglist *vec; +{ + if (noexec) + exit(0); + vec->al_argv[vec->al_argc] = 0; + execv(vec->al_argv[1], &(vec->al_argv[1])); + if (errno == ENOEXEC) { /* not an a.out, try it with the SHELL */ + vec->al_argv[0] = SHELL; + execv(SHELL, &(vec->al_argv[0])); + } + if (access(vec->al_argv[1], 1) == 0) { + /* File is executable. */ + error("cannot execute %s", vec->al_argv[1]); + } else { + error("%s is not executable", vec->al_argv[1]); + } + exit(1); +} diff --git a/fcc/driver/proto.make b/fcc/driver/proto.make new file mode 100644 index 000000000..d8d1bd4d5 --- /dev/null +++ b/fcc/driver/proto.make @@ -0,0 +1,38 @@ +# $Header$ + +#PARAMS do not remove this line! + +SRC_DIR = $(SRC_HOME)/fcc/driver +INCLUDES = -I$(TARGET_HOME)/config +CFLAGS = $(COPTIONS) $(INCLUDES) +LINTFLAGS = $(LINTOPTIONS) $(INCLUDES) +LDFLAGS = $(LDOPTIONS) + +all: fcc + +install: all + cp fcc $(TARGET_HOME)/bin + if [ $(DO_MACHINE_INDEP) = y ] ; \ + then mk_manpage $(SRC_DIR)/fcc.1 $(TARGET_HOME) ; \ + fi + +cmp: all + -cmp fcc $(TARGET_HOME)/bin/fcc + +pr: + @pr $(SRC_DIR)/proto.make $(SRC_DIR)/fcc.c + +opr: + make pr | opr + +clean: + rm -f *.$(SUF) fcc Out + +lint: + $(LINT) $(LINTFLAGS) -D`ack_sys` $(SRC_DIR)/driver.c + +fcc.$(SUF): $(SRC_DIR)/fcc.c $(TARGET_HOME)/config/em_path.h + $(CC) $(CFLAGS) -c -D$(MACH) -D`ack_sys` $(SRC_DIR)/fcc.c + +fcc: fcc.$(SUF) + $(CC) $(LDFLAGS) -o fcc fcc.$(SUF) diff --git a/mach/vax4/libce/.distr b/mach/vax4/libce/.distr new file mode 100644 index 000000000..a24fc2610 --- /dev/null +++ b/mach/vax4/libce/.distr @@ -0,0 +1,2 @@ +proto.make +sys.s diff --git a/mach/vax4/libce/proto.make b/mach/vax4/libce/proto.make new file mode 100644 index 000000000..a56b37db0 --- /dev/null +++ b/mach/vax4/libce/proto.make @@ -0,0 +1,32 @@ +# $Header$ + +#PARAMS do not remove this line! + +SRC_DIR = $(SRC_HOME)/mach/vax4/libce + +FOBJ = sys.o + +all: libext.a + +libext.a: $(TARGET_HOME)/lib/vax4/tail_em $(FOBJ) + aal x $(TARGET_HOME)/lib/vax4/tail_em + for i in *.o ; do $(TARGET_HOME)/lib.bin/vax4/cv -u $$i $$i.X ; mv $$i.X $$i ; done + ar rv libext.a *.o + ranlib libext.a + +$(FOBJ): + for i in $(SRC_DIR)/*.s ; do vax4 -c $$i ; done + +install: all + cp libext.a $(TARGET_HOME)/lib/vax4/tail_ext + ranlib $(TARGET_HOME)/lib/vax4/tail_ext + +cmp: all + -cmp libext.a $(TARGET_HOME)/lib/vax4/tail_ext + +clean: + rm -f *.[oa] + +pr: + +opr: diff --git a/mach/vax4/libce/sys.s b/mach/vax4/libce/sys.s new file mode 100644 index 000000000..97f0f6c2c --- /dev/null +++ b/mach/vax4/libce/sys.s @@ -0,0 +1,6 @@ +.sect .text +.define __write, __brk + +__write: jmp _write+2 + +__brk: jmp _brk+2