X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=main.c;h=35e3ceef180fc79facec642b50e4a79868943513;hb=9f6f0f7cf63b5f2f4b53d99f85577abd7980cbc0;hp=c78b1f3952b38f4d9a1aa62742d855a53859544c;hpb=97c9baa64459a7db94be6c80d615f99b189b95a2;p=cparser

diff --git a/main.c b/main.c
index c78b1f3..35e3cee 100644
--- a/main.c
+++ b/main.c
@@ -75,11 +75,12 @@
 #include "driver/firm_cmdline.h"
 #include "adt/error.h"
 #include "write_fluffy.h"
+#include "write_caml.h"
 #include "revision.h"
 #include "warning.h"
 
 #ifndef PREPROCESSOR
-#define PREPROCESSOR "cpp -std=c99 -U__WCHAR_TYPE__ -D__WCHAR_TYPE__=int"
+#define PREPROCESSOR "cpp -std=c99 -U__WCHAR_TYPE__ -D__WCHAR_TYPE__=int -U__SIZE_TYPE__ -D__SIZE_TYPE__=__SIZE_TYPE__ -m32"
 #endif
 
 #ifndef LINKER
@@ -102,6 +103,9 @@ bool char_is_signed = true;
 /** true for strict language checking. */
 bool strict_mode = false;
 
+/** use builtins for some libc functions */
+bool use_builtins = false;
+
 /* to switch on printing of implicit casts */
 extern bool print_implicit_casts;
 
@@ -111,6 +115,13 @@ extern bool print_parenthesis;
 static int            verbose;
 static struct obstack cppflags_obst, ldflags_obst;
 
+typedef struct file_list_entry_t file_list_entry_t;
+
+struct file_list_entry_t {
+	const char        *filename;
+	file_list_entry_t *next;
+};
+
 #if defined(_DEBUG) || defined(FIRM_DEBUG)
 /**
  * Debug printf implementation.
@@ -166,10 +177,21 @@ static void get_output_name(char *buf, size_t buflen, const char *inputname,
 	memcpy(buf+last_dot, newext, extlen);
 }
 
+#include "builtins.h"
+
 static translation_unit_t *do_parsing(FILE *const in, const char *const input_name)
 {
+	start_parsing();
+
+	if (use_builtins) {
+		lexer_open_buffer(builtins, sizeof(builtins)-1, "<builtin>");
+		parse();
+	}
+
 	lexer_open_stream(in, input_name);
-	translation_unit_t *unit = parse();
+	parse();
+
+	translation_unit_t *unit = finish_parsing();
 	return unit;
 }
 
@@ -184,6 +206,40 @@ static void lextest(FILE *in, const char *fname)
 	} while(lexer_token.type != T_EOF);
 }
 
+static void add_flag(struct obstack *obst, const char *format, ...)
+{
+	va_list ap;
+	va_start(ap, format);
+
+	char buf[4096];
+	vsnprintf(buf, sizeof(buf), format, ap);
+
+	/* escape stuff... */
+	obstack_1grow(obst, ' ');
+	for (char *c = buf; *c != '\0'; ++c) {
+		switch(*c) {
+		case '"':
+		case '\'':
+		case '`':
+		case ' ':
+		case '\t':
+		case '\n':
+		case '\r':
+		case '\\':
+		case '$':
+		case '(':
+		case ')':
+			obstack_1grow(obst, '\\');
+			/* fallthrough */
+		default:
+			obstack_1grow(obst, *c);
+			break;
+		}
+	}
+
+	va_end(ap);
+}
+
 static FILE *preprocess(FILE *in, const char *fname)
 {
 	char buf[4096];
@@ -200,6 +256,7 @@ static FILE *preprocess(FILE *in, const char *fname)
 	if(verbose) {
 		puts(buf);
 	}
+
 	FILE *f = popen(buf, "r");
 	if(f == NULL) {
 		fprintf(stderr, "invoking preprocessor failed\n");
@@ -338,6 +395,7 @@ void lower_compound_params(void)
 
 typedef enum compile_mode_t {
 	BenchmarkParser,
+	PreprocessOnly,
 	ParseOnly,
 	Compile,
 	CompileDump,
@@ -345,7 +403,11 @@ typedef enum compile_mode_t {
 	CompileAssembleLink,
 	LexTest,
 	PrintAst,
-	PrintFluffy
+	PrintFluffy,
+	PrintCaml,
+	Link,
+	Assemble,
+	AssemblePreprocessed,
 } compile_mode_t;
 
 static void usage(const char *argv0)
@@ -353,19 +415,68 @@ static void usage(const char *argv0)
 	fprintf(stderr, "Usage %s input [-o output] [-c]\n", argv0);
 }
 
+static void print_cparser_version(void) {
+	firm_version_t ver;
+	firm_get_version(&ver);
+
+	printf("cparser (%s) using libFirm (%u.%u",
+		cparser_REVISION, ver.major, ver.minor);
+	if(ver.revision[0] != 0) {
+		putchar(' ');
+		fputs(ver.revision, stdout);
+	}
+	if(ver.build[0] != 0) {
+		putchar(' ');
+		fputs(ver.build, stdout);
+	}
+	puts(")\n");
+}
+
+static void set_be_option(const char *arg)
+{
+	int res = firm_be_option(arg);
+	(void) res;
+	assert(res);
+}
+
+static void set_option(const char *arg)
+{
+	int res = firm_option(arg);
+	(void) res;
+	assert(res);
+}
+
+static void copy_file(FILE *dest, FILE *input)
+{
+	char buf[16384];
+
+	while (!feof(input) && !ferror(dest)) {
+		size_t read = fread(buf, 1, sizeof(buf), input);
+		if(fwrite(buf, 1, read, dest) != read) {
+			perror("couldn't write output");
+		}
+	}
+}
+
 int main(int argc, char **argv)
 {
 	initialize_firm();
 
-	const char     *input        = NULL;
-	const char     *outname      = NULL;
-	const char     *dumpfunction = NULL;
-	compile_mode_t  mode         = CompileAssembleLink;
-	int             opt_level    = 1;
-	int             result       = EXIT_SUCCESS;
+	const char        *input        = NULL;
+	const char        *outname      = NULL;
+	const char        *dumpfunction = NULL;
+	compile_mode_t     mode         = CompileAssembleLink;
+	int                opt_level    = 1;
+	int                result       = EXIT_SUCCESS;
+	char               cpu_arch[16] = "ia32";
+	file_list_entry_t *c_files      = NULL;
+	file_list_entry_t *s_files      = NULL;
+	file_list_entry_t *o_files      = NULL;
+	struct obstack     file_obst;
 
 	obstack_init(&cppflags_obst);
 	obstack_init(&ldflags_obst);
+	obstack_init(&file_obst);
 
 #define GET_ARG_AFTER(def, args)                                             \
 	def = &arg[sizeof(args)-1];                                              \
@@ -401,23 +512,24 @@ int main(int argc, char **argv)
 	/* apply optimisation level */
 	switch(opt_level) {
 	case 0:
-		firm_option("no-opt");
+		set_option("no-opt");
 		break;
 	case 1:
-		firm_option("no-inline");
+		set_option("no-inline");
 		break;
 	default:
 	case 4:
-		firm_option("strict-aliasing");
+		set_option("strict-aliasing");
 		/* fallthrough */
 	case 3:
-		firm_option("cond-eval");
-		firm_option("if-conv");
+		set_option("cond-eval");
+		set_option("if-conv");
+		use_builtins = true;
 		/* fallthrough */
 	case 2:
-		firm_option("inline");
-		firm_option("deconv");
-		firm_be_option("omitfp");
+		set_option("inline");
+		set_option("deconv");
+		set_be_option("omitfp");
 		break;
 	}
 
@@ -426,17 +538,19 @@ int main(int argc, char **argv)
 	bool argument_errors = false;
 	for(int i = 1; i < argc; ++i) {
 		const char *arg = argv[i];
-		if(arg[0] == '-') {
+		if(arg[0] == '-' && arg[1] != 0) {
 			/* an option */
 			const char *option = &arg[1];
 			if(option[0] == 'o') {
 				GET_ARG_AFTER(outname, "-o");
 			} else if(option[0] == 'g') {
-				firm_be_option("stabs=yes");
-				firm_be_option("omitfp=no");
-				firm_be_option("ia32-nooptcc=yes");
+				set_be_option("debuginfo=stabs");
+				set_be_option("omitfp=no");
+				set_be_option("ia32-nooptcc=yes");
 			} else if(SINGLE_OPTION('c')) {
 				mode = CompileAssemble;
+			} else if(SINGLE_OPTION('E')) {
+				mode = PreprocessOnly;
 			} else if(SINGLE_OPTION('S')) {
 				mode = Compile;
 			} else if(option[0] == 'O') {
@@ -444,27 +558,43 @@ int main(int argc, char **argv)
 			} else if(option[0] == 'I') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-I");
-				obstack_printf(&cppflags_obst, " -I%s", opt);
+				add_flag(&cppflags_obst, "-I%s", opt);
 			} else if(option[0] == 'D') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-D");
-				obstack_printf(&cppflags_obst, " -D%s", opt);
+				add_flag(&cppflags_obst, "-D%s", opt);
 			} else if(option[0] == 'U') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-U");
-				obstack_printf(&cppflags_obst, " -U%s", opt);
+				add_flag(&cppflags_obst, "-U%s", opt);
 			} else if(option[0] == 'l') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-l");
-				obstack_printf(&ldflags_obst, " -l%s", opt);
+				add_flag(&ldflags_obst, "-l%s", opt);
 			} else if(option[0] == 'L') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-L");
-				obstack_printf(&ldflags_obst, " -L%s", opt);
+				add_flag(&ldflags_obst, "-L%s", opt);
 			} else if(SINGLE_OPTION('v')) {
 				verbose = 1;
 			} else if(SINGLE_OPTION('w')) {
 				inhibit_all_warnings = true;
+			} else if(strcmp(option, "M") == 0) {
+				mode = PreprocessOnly;
+				add_flag(&cppflags_obst, "-M");
+			} else if(strcmp(option, "MMD") == 0
+					|| strcmp(option, "MD") == 0
+					|| strcmp(option, "MM") == 0) {
+				add_flag(&cppflags_obst, "-%s", option);
+			} else if(strcmp(option, "MT") == 0
+					|| strcmp(option, "MQ") == 0
+					|| strcmp(option, "MF") == 0) {
+				const char *opt;
+				GET_ARG_AFTER(opt, "-MT");
+				add_flag(&cppflags_obst, "-%s", option);
+				add_flag(&cppflags_obst, "%s", opt);
+			} else if(strcmp(option, "pipe") == 0) {
+				/* here for gcc compatibility */
 			} else if(option[0] == 'f') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-f");
@@ -472,9 +602,19 @@ int main(int argc, char **argv)
 				if(strcmp(opt, "syntax-only") == 0) {
 					mode = ParseOnly;
 				} else if(strcmp(opt, "omit-frame-pointer") == 0) {
-					firm_be_option("omitfp");
+					set_be_option("omitfp");
 				} else if(strcmp(opt, "no-omit-frame-pointer") == 0) {
-					firm_be_option("omitfp=no");
+					set_be_option("omitfp=no");
+				} else if(strcmp(opt, "strength-reduce") == 0) {
+					firm_option("strength-red");
+				} else if(strcmp(opt, "fast-math") == 0
+						|| strcmp(opt, "unroll-loops") == 0
+						|| strcmp(opt, "expensive-optimizations") == 0
+						|| strcmp(opt, "no-common") == 0
+						|| strncmp(opt, "align-loops=", sizeof("align-loops=")-1) == 0
+						|| strncmp(opt, "align-jumps=", sizeof("align-jumps=")-1) == 0
+						|| strncmp(opt, "align-functions=", sizeof("align-functions=")-1) == 0) {
+					fprintf(stderr, "ignoring gcc option '-f %s'\n", opt);
 				} else {
 					int res = firm_option(opt);
 					if (res == 0) {
@@ -496,23 +636,81 @@ int main(int argc, char **argv)
 					argument_errors = true;
 				} else if (res == -1) {
 					help_displayed = true;
+				} else {
+					if (strncmp(opt, "isa=", 4) == 0)
+						strncpy(cpu_arch, opt, sizeof(cpu_arch));
 				}
 			} else if(option[0] == 'W') {
 				set_warning_opt(&option[1]);
 			} else if(option[0] == 'm') {
+				/* -m options */
 				const char *opt;
+				char arch_opt[64];
+
 				GET_ARG_AFTER(opt, "-m");
-				char *endptr;
-				long int value = strtol(opt, &endptr, 10);
-				if (*endptr != '\0') {
-					fprintf(stderr, "error: wrong option '-m %s'\n",  opt);
-					argument_errors = true;
-				}
-				if (value != 16 && value != 32 && value != 64) {
-					fprintf(stderr, "error: option -m supports only 16, 32 or 64\n");
-					argument_errors = true;
+				if(strncmp(opt, "arch=", 5) == 0) {
+					GET_ARG_AFTER(opt, "-march=");
+					snprintf(arch_opt, sizeof(arch_opt), "%s-arch=%s", cpu_arch, opt);
+					int res = firm_be_option(arch_opt);
+					if (res == 0)
+						argument_errors = true;
+					else {
+						snprintf(arch_opt, sizeof(arch_opt), "%s-opt=%s", cpu_arch, opt);
+						int res = firm_be_option(arch_opt);
+						if (res == 0)
+							argument_errors = true;
+					}
+				} else if(strncmp(opt, "tune=", 5) == 0) {
+					GET_ARG_AFTER(opt, "-mtune=");
+					snprintf(arch_opt, sizeof(arch_opt), "%s-opt=%s", cpu_arch, opt);
+					int res = firm_be_option(arch_opt);
+					if (res == 0)
+						argument_errors = true;
+				} else if(strncmp(opt, "cpu=", 4) == 0) {
+					GET_ARG_AFTER(opt, "-mcpu=");
+					snprintf(arch_opt, sizeof(arch_opt), "%s-arch=%s", cpu_arch, opt);
+					int res = firm_be_option(arch_opt);
+					if (res == 0)
+						argument_errors = true;
+				} else if(strncmp(opt, "fpmath=", 7) == 0) {
+					GET_ARG_AFTER(opt, "-mfpmath=");
+					if(strcmp(opt, "387") == 0)
+						opt = "x87";
+					else if(strcmp(opt, "sse") == 0)
+						opt = "sse2";
+					else {
+						fprintf(stderr, "error: option -mfpumath supports only 387 or sse\n");
+						argument_errors = true;
+					}
+					if(!argument_errors) {
+						snprintf(arch_opt, sizeof(arch_opt), "%s-fpunit=%s", cpu_arch, opt);
+						int res = firm_be_option(arch_opt);
+						if (res == 0)
+							argument_errors = true;
+					}
+				} else if(strncmp(opt, "preferred-stack-boundary=", 25) == 0) {
+					GET_ARG_AFTER(opt, "-mpreferred-stack-boundary=");
+					snprintf(arch_opt, sizeof(arch_opt), "%s-stackalign=%s", cpu_arch, opt);
+					int res = firm_be_option(arch_opt);
+					if (res == 0)
+						argument_errors = true;
+				} else if(strcmp(opt, "omit-leaf-frame-pointer") == 0) {
+					set_be_option("omitleaffp=1");
+				} else if(strcmp(opt, "no-omit-leaf-frame-pointer") == 0) {
+					set_be_option("omitleaffp=0");
 				} else {
-					machine_size = (unsigned int)value;
+					char *endptr;
+					long int value = strtol(opt, &endptr, 10);
+					if (*endptr != '\0') {
+						fprintf(stderr, "error: wrong option '-m %s'\n",  opt);
+						argument_errors = true;
+					}
+					if (value != 16 && value != 32 && value != 64) {
+						fprintf(stderr, "error: option -m supports only 16, 32 or 64\n");
+						argument_errors = true;
+					} else {
+						machine_size = (unsigned int)value;
+					}
 				}
 			} else if (option[0] == '\0') {
 				if(input != NULL) {
@@ -522,10 +720,12 @@ int main(int argc, char **argv)
 					input = arg;
 				}
 			} else if(strcmp(option, "pg") == 0) {
-				firm_be_option("-b gprof");
-				obstack_printf(&ldflags_obst, " -pg");
+				set_be_option("gprof");
+				add_flag(&ldflags_obst, "-pg");
 			} else if(strcmp(option, "pedantic") == 0) {
 				fprintf(stderr, "warning: ignoring gcc option '%s'\n", arg);
+			} else if(strcmp(option, "shared") == 0) {
+				add_flag(&ldflags_obst, "-shared");
 			} else if(strncmp(option, "std=", 4) == 0) {
 				if(strcmp(&option[4], "c99") == 0) {
 					c_mode = _C89|_C99;
@@ -537,6 +737,8 @@ int main(int argc, char **argv)
 					c_mode = _C89|_C99|_MS;
 				} else
 					fprintf(stderr, "warning: ignoring gcc option '%s'\n", arg);
+			} else if(strcmp(option, "version") == 0) {
+				print_cparser_version();
 			} else if (option[0] == '-') {
 				/* double dash option */
 				++option;
@@ -566,20 +768,10 @@ int main(int argc, char **argv)
 					print_parenthesis = true;
 				} else if(strcmp(option, "print-fluffy") == 0) {
 					mode = PrintFluffy;
+				} else if(strcmp(option, "print-caml") == 0) {
+					mode = PrintCaml;
 				} else if(strcmp(option, "version") == 0) {
-					firm_version_t ver;
-					firm_get_version(&ver);
-					printf("cparser (%s) using libFirm (%u.%u",
-					       cparser_REVISION, ver.major, ver.minor);
-					if(ver.revision[0] != 0) {
-						putchar(' ');
-						fputs(ver.revision, stdout);
-					}
-					if(ver.build[0] != 0) {
-						putchar(' ');
-						fputs(ver.build, stdout);
-					}
-					puts(")\n");
+					print_cparser_version();
 					exit(EXIT_SUCCESS);
 				} else if(strcmp(option, "dump-function") == 0) {
 					++i;
@@ -600,22 +792,65 @@ int main(int argc, char **argv)
 				argument_errors = true;
 			}
 		} else {
-			if(input != NULL) {
-				fprintf(stderr, "error: multiple input files specified\n");
-				argument_errors = true;
+
+			file_list_entry_t *entry
+				= obstack_alloc(&file_obst, sizeof(entry[0]));
+			entry->filename = arg;
+
+			size_t len = strlen(arg);
+			if (len < 2) {
+				if (arg[0] == '-') {
+					/* exception: '-' as name reads C from stdin */
+					entry->next = c_files;
+					c_files     = entry;
+					continue;
+				}
+				fprintf(stderr, "'%s': file format not recognized\n", input);
+				continue;
+			}
+
+			if (strcmp(arg+len-2, ".c") == 0
+					|| strcmp(arg+len-2, ".h") == 0) {
+				entry->next = c_files;
+				c_files     = entry;
+			} else if (strcmp(arg+len-2, ".s") == 0 || strcmp(arg+len-2, ".S") == 0) {
+				entry->next = s_files;
+				s_files     = entry;
+			} else if (strcmp(arg+len-2, ".o") == 0) {
+				entry->next = o_files;
+				o_files     = entry;
 			} else {
-				input = arg;
+				fprintf(stderr, "'%s': file format not recognized\n", input);
 			}
 		}
 	}
 
+	if (c_files == NULL && s_files == NULL && o_files != NULL) {
+		mode = Link;
+	} else if (c_files != NULL && c_files->next == NULL) {
+		input = c_files->filename;
+	} else if (s_files != NULL && s_files->next == NULL) {
+		input = s_files->filename;
+		if(!strcmp(input + strlen(input) - 2, ".S"))
+			mode = AssemblePreprocessed;
+		else
+			mode = Assemble;
+	} else {
+		if (c_files == NULL && s_files == NULL) {
+			fprintf(stderr, "error: no input files specified\n");
+		} else {
+			fprintf(stderr, "error: multiple input files specified\n");
+		}
+		argument_errors = true;
+	}
+
 	/* we do the lowering in ast2firm */
 	firm_opt.lower_bitfields = FALSE;
 
-	if(help_displayed) {
+	if (help_displayed) {
 		return !argument_errors;
 	}
-	if(argument_errors) {
+	if (argument_errors) {
 		usage(argv[0]);
 		return 1;
 	}
@@ -638,9 +873,10 @@ int main(int argc, char **argv)
 		case BenchmarkParser:
 		case PrintAst:
 		case PrintFluffy:
+		case PrintCaml:
 		case LexTest:
-			if(outname == NULL)
-				outname = "-";
+		case PreprocessOnly:
+			outname = "-";
 			break;
 		case ParseOnly:
 			break;
@@ -657,6 +893,7 @@ int main(int argc, char **argv)
 			                ".vcg");
 			outname = outnamebuf;
 			break;
+		case Link:
 		case CompileAssembleLink:
 #ifdef _WIN32
 			/* Windows compiler typically derive the output name from
@@ -670,6 +907,38 @@ int main(int argc, char **argv)
 		}
 	}
 
+	if (mode == Assemble) {
+		assemble(outname, input);
+		return 0;
+	}
+
+	if (mode == Link) {
+		obstack_1grow(&ldflags_obst, '\0');
+		const char *flags = obstack_finish(&ldflags_obst);
+
+		obstack_printf(&file_obst, "%s", LINKER);
+
+		for (file_list_entry_t *entry = o_files; entry != NULL;
+				entry = entry->next) {
+			obstack_printf(&file_obst, " %s", entry->filename);
+		}
+
+		obstack_printf(&file_obst, " -o %s %s", outname, flags);
+		obstack_1grow(&file_obst, '\0');
+
+		char *buf = obstack_finish(&file_obst);
+
+		if(verbose) {
+			puts(buf);
+		}
+		int err = system(buf);
+		if(err != 0) {
+			fprintf(stderr, "linker reported an error\n");
+			exit(1);
+		}
+		return 0;
+	}
+
 	if(outname != NULL) {
 		if(strcmp(outname, "-") == 0) {
 			out = stdout;
@@ -705,9 +974,31 @@ int main(int argc, char **argv)
 	}
 
 	FILE *preprocessed_in = preprocess(in, input);
+	if (mode == PreprocessOnly) {
+		copy_file(out, preprocessed_in);
+		return pclose(preprocessed_in);
+	}
+
+	if (mode == AssemblePreprocessed) {
+		FILE *asm_pp;
+		char  asm_tempfile[1024];
+
+		/* write preprocessed assembler to a temporary file */
+		asm_pp = make_temp_file(asm_tempfile, sizeof(asm_tempfile), "cc", ".s");
+		copy_file(asm_pp, preprocessed_in);
+		fclose(asm_pp);
+		int res = pclose(preprocessed_in);
+		if (res != 0)
+			return res;
+
+		/* and assemble it */
+		assemble(outname, asm_tempfile);
+		return 0;
+	}
+
 	translation_unit_t *const unit = do_parsing(preprocessed_in, input);
 	int res = pclose(preprocessed_in);
-	if(res != 0) {
+	if (res != 0) {
 		return res;
 	}
 
@@ -736,10 +1027,11 @@ int main(int argc, char **argv)
 		return result;
 
 	if(mode == PrintFluffy) {
-		type_set_output(out);
-		ast_set_output(out);
 		write_fluffy_decls(out, unit);
 	}
+	if (mode == PrintCaml) {
+		write_caml_decls(out, unit);
+	}
 
 	translation_unit_to_firm(unit);
 
@@ -810,6 +1102,7 @@ int main(int argc, char **argv)
 
 	obstack_free(&cppflags_obst, NULL);
 	obstack_free(&ldflags_obst, NULL);
+	obstack_free(&file_obst, NULL);
 
 	exit_ast2firm();
 	exit_parser();