mi-sched: Reorder Cyclicpath (latency) and CriticalMax (pressure) heuristics.
[oota-llvm.git] / utils / llvm-native-gcc
1 #!/usr/bin/perl
2 # Wrapper around LLVM tools to generate a native .o from llvm-gcc using an
3 # LLVM back-end (CBE by default).
4
5 # set up defaults.
6 $Verbose = 0;
7 $SaveTemps = 1;
8 $PreprocessOnly = 0;
9 $CompileDontLink = 0;
10 $Backend = 'cbe';
11 chomp ($ProgramName = `basename $0`);
12
13 sub boldprint {
14         print "\e[1m", @_, "\e[0m";
15 }
16
17 # process command-line options.
18 # most of these are passed on to llvm-gcc.
19 $GCCOptions = "";
20 for ($i = 0; $i <= $#ARGV; ++$i) {      
21         if ($ARGV[$i] =~ /-mllvm-backend=([a-z0-9]*)/) {
22                 $Backend = $1;
23                 if ($ProgramName =~ /llvm-native-gcc/) {
24                         splice (@ARGV, $i, 1);
25                         --$i;
26                 }
27         } elsif ($ARGV[$i] eq "-E") {
28                 $PreprocessOnly = 1;
29         } elsif ($ARGV[$i] eq "-c") {
30                 $GCCOptions .= " " . $ARGV[$i];
31                 $CompileDontLink = 1;
32         } elsif ($ARGV[$i] eq "-v") {
33                 $GCCOptions .= " " . $ARGV[$i];
34                 $Verbose = 1;
35         } elsif ($ARGV[$i] eq "-o") {
36                 $OutputFile = $ARGV[$i + 1];
37         } elsif ($ARGV[$i] eq "-save-temps") {
38                 $GCCOptions .= " " . $ARGV[$i];
39                 $SaveTemps = 1;
40         } elsif ($ARGV[$i] =~ /\.bc$/) {
41                 push (@BytecodeFiles, $ARGV[$i]);
42         } elsif ($ARGV[$i] =~ /^-L/) {
43                 $GCCOptions .= " " . $ARGV[$i];
44                 push (@LibDirs, $ARGV[$i]);
45         } elsif ($ARGV[$i] =~ /^-l/) {
46                 $GCCOptions .= " " . $ARGV[$i];
47                 push (@Libs, $ARGV[$i]);
48         } elsif ($ARGV[$i] =~ /\.(c|cpp|cc|i|ii|C)$/) {
49                 $LastCFile = $ARGV[$i];
50         }
51 }
52
53 sub GetDefaultOutputFileName {
54         my $DefaultOutputFileBase;
55
56         if ($ProgramName =~ /llvm-native-gcc/) {
57                 $DefaultOutputFileBase = $LastCFile;
58         } elsif ($ProgramName =~ /native-build/) {
59                 $DefaultOutputFileBase = $BytecodeFiles[0];
60         }
61
62         my $def = $DefaultOutputFileBase;
63
64         die "Can't figure out name of output file.\n"
65                 unless $DefaultOutputFileBase
66                            && (($ProgramName !~ /native-build/)
67                                    || $#BytecodeFiles == 0);
68
69         print "Warning: defaulting output file name ",
70                 "based on '$DefaultOutputFileBase'\n" if $Verbose;
71
72         if ($ProgramName =~ /llvm-native-gcc/) {
73                 $def =~ s/\.(c|cpp|cc|i|ii|C)$/.o/;
74         } elsif ($ProgramName =~ /native-build/) {
75                 $def =~ s/\.bc$/.$Backend/;
76                 if ($CompileDontLink) {
77                         $def .= ".o";
78                 }
79         }
80
81         return $def;
82 }
83
84 # run a command, optionally echoing, and quitting if it fails:
85 sub run {
86         my $command = join(" ", @_);
87         print "$command\n" if $Verbose;
88         $command =~ s/\"/\\\"/g;
89         system $command and die "$0: $command failed";
90 }
91
92 sub LinkBytecodeFilesIntoTemporary {
93         my $FinalOutputFileName = shift @_;
94         my @BytecodeFiles = @_;
95
96         my $BCFiles = join (" ", @BytecodeFiles);
97         my $LinkedBCFile;
98         if ($SaveTemps) {
99                 $LinkedBCFile = "${FinalOutputFileName}.llvm.bc";
100         } else {
101                 $LinkedBCFile = "/tmp/nativebuild-$$.llvm.bc";
102         }
103         run "llvm-link -o $LinkedBCFile $BCFiles";
104         return $LinkedBCFile;
105 }
106
107 sub CompileBytecodeToNative {
108         my ($BCFile, $Backend, $OutputFile) = @_;
109
110         my $GeneratedCode;
111         if ($Backend eq 'cbe') {
112                 if ($SaveTemps) {
113                         $GeneratedCode = "${OutputFile}.c";
114                 } else {
115                         $GeneratedCode = "/tmp/nativebuild-$$.c";
116                 }
117                 run "llc -enable-correct-eh-support -march=c -f -o $GeneratedCode $BCFile";
118         } elsif ($Backend eq 'llc') {
119                 if ($SaveTemps) {
120                         $GeneratedCode = "${OutputFile}.s";
121                 } else {
122                         $GeneratedCode = "/tmp/nativebuild-$$.s";
123                 }
124                 run "llc -enable-correct-eh-support -f -o $GeneratedCode $BCFile";
125         }
126         my $LibDirs = join (" ", @LibDirs);
127         my $Libs = join (" ", @Libs);
128         run "gcc $GCCOptions $GeneratedCode -o $OutputFile $LibDirs $Libs";
129         run "rm $BCFile $GeneratedCode"
130                 unless $SaveTemps;
131 }
132
133 sub CompileCToNative {
134         my ($LLVMGCCCommand, $Backend, $OutputFile) = @_;
135         run $LLVMGCCCommand;
136         if ($PreprocessOnly) {
137                 return;
138         }
139         my $BCFile = "${OutputFile}.llvm.bc";
140         if ($CompileDontLink) {
141                 run "mv ${OutputFile} $BCFile";
142         } else { # gccld messes with the output file name
143                 run "mv ${OutputFile}.bc $BCFile";
144         }
145         my $GeneratedCode;
146         if ($Backend eq 'cbe') {
147                 $GeneratedCode = "${OutputFile}.cbe.c";
148                 run "llc -enable-correct-eh-support -march=c -f -o $GeneratedCode $BCFile";
149         } elsif ($Backend eq 'llc') {
150                 $GeneratedCode = "${OutputFile}.llc.s";
151                 run "llc -enable-correct-eh-support -f -o $GeneratedCode $BCFile";
152         }
153         my $NativeGCCOptions = "";
154         if ($CompileDontLink) {
155                 $NativeGCCOptions = "-c";
156         }
157         run "gcc $NativeGCCOptions $GeneratedCode -o $OutputFile";
158         run "rm ${OutputFile}.llvm.bc $GeneratedCode"
159                 unless $SaveTemps;
160 }
161
162 # guess the name of the output file, if -o was not specified.
163 $OutputFile = GetDefaultOutputFileName () unless $OutputFile;
164 print "Output file is $OutputFile\n" if $Verbose;
165 # do all the dirty work:
166 if ($ProgramName eq /native-build/) {
167         my $LinkedBCFile = LinkBytecodeFilesIntoTemporary (@BytecodeFiles);
168         CompileBytecodeToNative ($LinkedBCFile, $Backend, $OutputFile);
169 } elsif ($ProgramName =~ /llvm-native-gcc/) {
170         # build the llvm-gcc command line.
171         $LLVMGCCCommand = join (" ", ("llvm-gcc", @ARGV));
172         CompileCToNative ($LLVMGCCCommand, $Backend, $OutputFile);
173 }
174
175 # we're done.
176 exit 0;
177
178 __END__
179
180 =pod
181
182 =head1 NAME
183
184 llvm-native-gcc
185
186 =head1 SYNOPSIS
187
188 llvm-native-gcc [OPTIONS...] FILE
189
190 native-build [OPTIONS...] FILE
191
192 =head1 DESCRIPTION
193
194 llvm-native-gcc is a wrapper around the LLVM command-line tools which generates
195 a native object (.o) file by compiling FILE with llvm-gcc, and then running 
196 an LLVM back-end (CBE by default) over the resulting bitcode, and then
197 compiling the resulting code to a native object file.
198
199 If called as "native-build", it compiles bitcode to native code, and takes
200 different options.
201
202 =head1 OPTIONS
203
204 llvm-native-gcc takes the same options as llvm-gcc. All options
205 except -mllvm-backend=... are passed on to llvm-gcc.
206
207 =over 4
208
209 =item -mllvm-backend=BACKEND
210
211 Use BACKEND for native code generation. 
212
213 =item -v
214
215 Print command lines that llvm-native-gcc runs.
216
217 =item -o FILE
218
219 llvm-native-gcc tries to guess the name of the llvm-gcc output file by looking
220 for this option in the command line. If it can't find it, it finds the last C
221 or C++ source file named on the command line, and turns its suffix into .o. See
222 BUGS.
223
224 =item -save-temps
225
226 Save temporary files used by llvm-native-gcc (and llvm-gcc, and gcc).
227
228 =back
229
230 =head1 BUGS
231
232 llvm-native-gcc only handles the case where llvm-gcc compiles a single
233 file per invocation.  llvm-native-gcc has weak command-line argument
234 parsing and is a poor substitute for making gcc/gcc.c do this stuff.
235
236 This manual page does not adequately document native-build mode.
237
238 llvm-native-gcc is pretty gross because it represents the blind merging of two
239 other scripts that predated it. It could use some code clean-up.
240
241 =head1 SEE ALSO
242
243 gcc(1)
244
245 =head1 AUTHOR
246
247 Brian R. Gaeke
248
249 =cut