def SetupChain(chain, input_type, output_type): assert (output_type in ('pp', 'll', 'po', 's', 'o')) cur_type = input_type # source file -> pp if filetype.IsSourceType(cur_type) and output_type == 'pp': chain.add(RunCC, 'cpp', mode='-E') cur_type = 'pp' if cur_type == output_type: return # header file -> pre-process if filetype.IsHeaderType(cur_type) and output_type == 'pp': chain.add(RunCC, 'cpp', mode='-E') cur_type = 'pp' if cur_type == output_type: return # source file -> ll if (filetype.IsSourceType(cur_type) and (env.getbool('FORCE_INTERMEDIATE_LL') or output_type == 'll')): chain.add(RunCC, 'll', mode='-S') cur_type = 'll' if cur_type == output_type: return # ll -> po if cur_type == 'll': chain.add(RunLLVMAS, 'po') cur_type = 'po' if cur_type == output_type: return # source file -> po (we also force native output to go through this phase if filetype.IsSourceType(cur_type) and output_type in ('po', 'o', 's'): chain.add(RunCC, 'po', mode='-c') cur_type = 'po' if cur_type == output_type: return # po -> o if (cur_type == 'po' and output_type == 'o'): # If we aren't using biased bitcode, then at least -expand-byval # must be run to work with the PPAPI shim calling convention. if IsPortable(): chain.add(RunOpt, 'expand.po', pass_list=['-expand-byval']) chain.add(RunTranslate, 'o', mode='-c') cur_type = 'o' if cur_type == output_type: return # po -> s if cur_type == 'po': # If we aren't using biased bitcode, then at least -expand-byval # must be run to work with the PPAPI shim calling convention. if IsPortable(): chain.add(RunOpt, 'expand.po', pass_list=['-expand-byval']) chain.add(RunTranslate, 's', mode='-S') cur_type = 's' if cur_type == output_type: return # S -> s if cur_type == 'S': chain.add(RunCC, 's', mode='-E') cur_type = 's' if output_type == 'pp': return if cur_type == output_type: return # s -> o if cur_type == 's' and output_type == 'o': chain.add(RunNativeAS, 'o') cur_type = 'o' if cur_type == output_type: return Log.Fatal("Unable to compile .%s to .%s", input_type, output_type)
def main(argv): env.update(EXTRA_ENV) CheckSetup() ParseArgs(argv, CustomPatterns + GCCPatterns) # "configure", especially when run as part of a toolchain bootstrap # process, will invoke gcc with various diagnostic options and # parse the output. In these cases we do not alter the incoming # commandline. It is also important to not emit spurious messages. if env.getbool('DIAGNOSTIC'): if env.getbool('SHOW_VERSION'): code, stdout, stderr = Run(env.get('CC') + env.get('CC_FLAGS'), redirect_stdout=subprocess.PIPE) out = stdout.split('\n') nacl_version = ReadDriverRevision() out[0] += ' nacl-version=%s' % nacl_version stdout = '\n'.join(out) print stdout, else: Run(env.get('CC') + env.get('CC_FLAGS')) return 0 unmatched = env.get('UNMATCHED') if len(unmatched) > 0: UnrecognizedOption(*unmatched) # If -arch was given, we are compiling directly to native code compiling_to_native = GetArch() is not None if env.getbool('ALLOW_NATIVE'): if not compiling_to_native: Log.Fatal("--pnacl-allow-native without -arch is not meaningful.") # For native/mixed links, also bring in the native libgcc and # libcrt_platform to avoid link failure if pre-translated native # code needs functions from it. env.append('LD_FLAGS', env.eval('-L${LIBS_NATIVE_ARCH}')) env.append('STDLIBS', '-lgcc') env.append('STDLIBS', '-lcrt_platform') flags_and_inputs = env.get('INPUTS') output = env.getone('OUTPUT') if len(flags_and_inputs) == 0: if env.getbool('VERBOSE'): # -v can be invoked without any inputs. Runs the original # command without modifying the commandline for this case. Run(env.get('CC') + env.get('CC_FLAGS')) return 0 else: Log.Fatal('No input files') gcc_mode = env.getone('GCC_MODE') output_type = DriverOutputTypes(gcc_mode, compiling_to_native) # '-shared' modifies the output from the linker and should be considered when # determining the final output type. if env.getbool('SHARED'): if compiling_to_native: Log.Fatal('Building native shared libraries not supported') if gcc_mode != '': Log.Fatal('-c, -S, and -E are disallowed with -shared') output_type = 'pll' # INPUTS consists of actual input files and a subset of flags like -Wl,<foo>. # Create a version with just the files. inputs = [f for f in flags_and_inputs if not IsFlag(f)] header_inputs = [ f for f in inputs if filetype.IsHeaderType(filetype.FileType(f)) ] # Handle PCH case specially (but only for a limited sense...) if header_inputs and gcc_mode != '-E': # We only handle doing pre-compiled headers for all inputs or not at # all at the moment. This is because DriverOutputTypes only assumes # one type of output, depending on the "gcc_mode" flag. When mixing # header inputs w/ non-header inputs, some of the outputs will be # pch while others will be output_type. We would also need to modify # the input->output chaining for the needs_linking case. if len(header_inputs) != len(inputs): Log.Fatal('mixed compiling of headers and source not supported') CompileHeaders(header_inputs, output) return 0 needs_linking = (gcc_mode == '') if env.getbool('NEED_DASH_E') and gcc_mode != '-E': Log.Fatal("-E or -x required when input is from stdin") # There are multiple input files and no linking is being done. # There will be multiple outputs. Handle this case separately. if not needs_linking: if output != '' and len(inputs) > 1: Log.Fatal( 'Cannot have -o with -c, -S, or -E and multiple inputs: %s', repr(inputs)) for f in inputs: intype = filetype.FileType(f) if not (filetype.IsSourceType(intype) or filetype.IsHeaderType(intype)): if ((output_type == 'pp' and intype != 'S') or (output_type == 'll') or (output_type == 'po' and intype != 'll') or (output_type == 's' and intype not in ('ll', 'po', 'S')) or (output_type == 'o' and intype not in ('ll', 'po', 'S', 's'))): Log.Fatal("%s: Unexpected type of file for '%s'", pathtools.touser(f), gcc_mode) if output == '': f_output = DefaultOutputName(f, output_type) else: f_output = output namegen = TempNameGen([f], f_output) CompileOne(f, output_type, namegen, f_output) return 0 # Linking case assert (needs_linking) assert (output_type in ('pll', 'pexe', 'nexe')) if output == '': output = pathtools.normalize('a.out') namegen = TempNameGen(flags_and_inputs, output) # Compile all source files (c/c++/ll) to .po for i in xrange(0, len(flags_and_inputs)): if IsFlag(flags_and_inputs[i]): continue intype = filetype.FileType(flags_and_inputs[i]) if filetype.IsSourceType(intype) or intype == 'll': flags_and_inputs[i] = CompileOne(flags_and_inputs[i], 'po', namegen) # Compile all .s/.S to .o if env.getbool('ALLOW_NATIVE'): for i in xrange(0, len(flags_and_inputs)): if IsFlag(flags_and_inputs[i]): continue intype = filetype.FileType(flags_and_inputs[i]) if intype in ('s', 'S'): flags_and_inputs[i] = CompileOne(flags_and_inputs[i], 'o', namegen) # We should only be left with .po and .o and libraries for f in flags_and_inputs: if IsFlag(f): continue intype = filetype.FileType(f) if intype in ('o', 's', 'S') or filetype.IsNativeArchive(f): if not env.getbool('ALLOW_NATIVE'): Log.Fatal( '%s: Native object files not allowed in link. ' 'Use --pnacl-allow-native to override.', pathtools.touser(f)) assert (intype in ('po', 'o', 'so', 'ldscript') or filetype.IsArchive(f)) # Fix the user-specified linker arguments ld_inputs = [] for f in flags_and_inputs: if f.startswith('-Xlinker='): ld_inputs.append(f[len('-Xlinker='):]) elif f.startswith('-Wl,'): ld_inputs += f[len('-Wl,'):].split(',') else: ld_inputs.append(f) if env.getbool('ALLOW_NATIVE'): ld_inputs.append('--pnacl-allow-native') # Invoke the linker env.set('ld_inputs', *ld_inputs) ld_args = env.get('LD_ARGS') ld_flags = env.get('LD_FLAGS') RunDriver('pnacl-ld', ld_flags + ld_args + ['-o', output]) return 0