diff options
Diffstat (limited to 'utils/llvm-config')
| -rw-r--r-- | utils/llvm-config/Makefile | 44 | ||||
| -rwxr-xr-x | utils/llvm-config/find-cycles.pl | 162 | ||||
| -rw-r--r-- | utils/llvm-config/llvm-config.in.in | 364 |
3 files changed, 569 insertions, 1 deletions
diff --git a/utils/llvm-config/Makefile b/utils/llvm-config/Makefile index 34dfa55..8a11a27 100644 --- a/utils/llvm-config/Makefile +++ b/utils/llvm-config/Makefile @@ -1,5 +1,5 @@ ##===- utils/llvm-config/Makefile --------------------------*- Makefile -*-===## -# +# # The LLVM Compiler Infrastructure # # This file was developed by Reid Spencer and Eric Kidd and is distributed under @@ -12,5 +12,47 @@ LEVEL = ../.. include $(LEVEL)/Makefile.common +# Combine preprocessor flags (except for -I) and CXX flags. +SUB_CXXFLAGS = ${CPP.BaseFlags} ${CXX.Flags} + +# This is blank for now. We need to be careful about adding stuff here: +# LDFLAGS tend not to be portable, and we don't currently require the +# user to use libtool when linking against LLVM. +SUB_LDFLAGS = + +# MANUAL USE ONLY! GenLibDeps.pl is very non-portable, so LibDeps.txt +# should only be re-built manually. No other rule in this file should +# depend on LibDeps.txt. LibDeps.txt: $(LEVEL)/utils/GenLibDeps.pl $(LibDir) $(LEVEL)/utils/GenLibDeps.pl -flat $(LibDir) | sort > LibDeps.txt + +# Find all the cyclic dependencies between various LLVM libraries, so we +# don't have to process them at runtime. +FinalLibDeps.txt: find-cycles.pl # LibDeps.txt deliberately omitted. + $(Echo) "Finding cyclic dependencies between LLVM libraries." + $(Verb) $< < $(PROJ_SRC_DIR)/LibDeps.txt > $@ + +# Rerun our configure substitutions as needed. +llvm-config.in: llvm-config.in.in $(ConfigStatusScript) + $(Verb) cd $(PROJ_OBJ_ROOT) ; \ + $(ConfigStatusScript) utils/llvm-config/llvm-config.in + +# Build our final script. +llvm-config: llvm-config.in FinalLibDeps.txt + $(Echo) "Building llvm-config script." + $(Verb) $(ECHO) 's,@LLVM_CXXFLAGS@,$(SUB_CXXFLAGS),' > temp.sed + $(Verb) $(ECHO) 's,@LLVM_LDFLAGS@,$(SUB_LDFLAGS),' >> temp.sed + $(Verb) $(ECHO) 's,@CORE_IS_ARCHIVE@,$(CORE_IS_ARCHIVE),' >> temp.sed + $(Verb) $(SED) -f temp.sed < $< > $@ + $(Verb) $(RM) temp.sed + $(Verb) cat FinalLibDeps.txt >> $@ + $(Verb) chmod +x llvm-config + +# Hook into the standard Makefile rules. +all-local:: llvm-config +clean-local:: + $(Verb) $(RM) -f FinalLibDeps.txt llvm-config llvm-config.in +install-local:: all-local + $(Echo) Installing llvm-config + $(Verb) $(MKDIR) $(PROJ_bindir) + $(Verb) $(ScriptInstall) llvm-config $(PROJ_bindir) diff --git a/utils/llvm-config/find-cycles.pl b/utils/llvm-config/find-cycles.pl new file mode 100755 index 0000000..b660955 --- /dev/null +++ b/utils/llvm-config/find-cycles.pl @@ -0,0 +1,162 @@ +#!/usr/bin/perl +# +# Program: find-cycles.pl +# +# Synopsis: Given a list of possibly cyclic dependencies, merge all the +# cycles. This makes it possible to topologically sort the +# dependencies between different parts of LLVM. +# +# Syntax: find-cycles.pl < LibDeps.txt > FinalLibDeps.txt +# +# Input: cycmem1: cycmem2 dep1 dep2 +# cycmem2: cycmem1 dep3 dep4 +# boring: dep4 +# +# Output: cycmem1 cycmem2: dep1 dep2 dep3 dep4 +# boring: dep4 +# +# This file was written by Eric Kidd, and is placed into the public domain. +# + +use strict; +use warnings; + +my %DEPS; +my @CYCLES; +sub find_all_cycles; + +# Read our dependency information. +while (<>) { + chomp; + my ($module, $dependency_str) = /^([^:]*): ?(.*)$/; + die "Malformed data: $_" unless defined $dependency_str; + my @dependencies = split(/ /, $dependency_str); + $DEPS{$module} = \@dependencies; +} + +# Partition our raw dependencies into sets of cyclically-connected nodes. +find_all_cycles(); + +# Print out the finished cycles, with their dependencies. +my @output; +foreach my $cycle (@CYCLES) { + my @modules = sort keys %{$cycle}; + + # Merge the dependencies of all modules in this cycle. + my %dependencies; + foreach my $module (@modules) { + @dependencies{@{$DEPS{$module}}} = 1; + } + + # Prune the known cyclic dependencies. + foreach my $module (@modules) { + delete $dependencies{$module}; + } + + # Warn about possible linker problems. + my @archives = grep(/\.a$/, @modules); + if (@archives > 1) { + print STDERR "find-cycles.pl: Circular dependency between *.a files:\n"; + print STDERR "find-cycles.pl: ", join(' ', @archives), "\n"; + print STDERR "find-cycles.pl: Some linkers may have problems.\n"; + push @modules, @archives; # WORKAROUND: Duplicate *.a files. Ick. + } + + # Add to our output. (@modules is already as sorted as we need it to be.) + push @output, (join(' ', @modules) . ': ' . + join(' ', sort keys %dependencies) . "\n"); +} +print sort @output; + + +#========================================================================== +# Depedency Cycle Support +#========================================================================== +# For now, we have cycles in our dependency graph. Ideally, each cycle +# would be collapsed down to a single *.a file, saving us all this work. +# +# To understand this code, you'll need a working knowledge of Perl 5, +# and possibly some quality time with 'man perlref'. + +my %SEEN; +my %CYCLES; +sub find_cycles ($@); +sub found_cycles ($@); + +sub find_all_cycles { + # Find all multi-item cycles. + my @modules = sort keys %DEPS; + foreach my $module (@modules) { find_cycles($module); } + + # Build fake one-item "cycles" for the remaining modules, so we can + # treat them uniformly. + foreach my $module (@modules) { + unless (defined $CYCLES{$module}) { + my %cycle = ($module, 1); + $CYCLES{$module} = \%cycle; + } + } + + # Find all our unique cycles. We have to do this the hard way because + # we apparently can't store hash references as hash keys without making + # 'strict refs' sad. + my %seen; + foreach my $cycle (values %CYCLES) { + unless ($seen{$cycle}) { + $seen{$cycle} = 1; + push @CYCLES, $cycle; + } + } +} + +# Walk through our graph depth-first (keeping a trail in @path), and report +# any cycles we find. +sub find_cycles ($@) { + my ($module, @path) = @_; + if (str_in_list($module, @path)) { + found_cycle($module, @path); + } else { + return if defined $SEEN{$module}; + $SEEN{$module} = 1; + foreach my $dep (@{$DEPS{$module}}) { + find_cycles($dep, @path, $module); + } + } +} + +# Give a cycle, attempt to merge it with pre-existing cycle data. +sub found_cycle ($@) { + my ($module, @path) = @_; + + # Pop any modules which aren't part of our cycle. + while ($path[0] ne $module) { shift @path; } + #print join("->", @path, $module) . "\n"; + + # Collect the modules in our cycle into a hash. + my %cycle; + foreach my $item (@path) { + $cycle{$item} = 1; + if (defined $CYCLES{$item}) { + # Looks like we intersect with an existing cycle, so merge + # all those in, too. + foreach my $old_item (keys %{$CYCLES{$item}}) { + $cycle{$old_item} = 1; + } + } + } + + # Update our global cycle table. + my $cycle_ref = \%cycle; + foreach my $item (keys %cycle) { + $CYCLES{$item} = $cycle_ref; + } + #print join(":", sort keys %cycle) . "\n"; +} + +sub str_in_list ($@) { + my ($str, @list) = @_; + foreach my $item (@list) { + return 1 if ($item eq $str); + } + return 0; +} diff --git a/utils/llvm-config/llvm-config.in.in b/utils/llvm-config/llvm-config.in.in new file mode 100644 index 0000000..6f1533c --- /dev/null +++ b/utils/llvm-config/llvm-config.in.in @@ -0,0 +1,364 @@ +#!/usr/bin/perl +# +# Program: llvm-config +# +# Synopsis: Prints out compiler options needed to build against an installed +# copy of LLVM. +# +# Syntax: lllvm-config OPTIONS... [COMPONENTS...] +# +# This file was written by Eric Kidd, and is placed into the public domain. +# + +use strict; +use warnings; + +#---- begin autoconf values ---- +my $VERSION = q{@PACKAGE_VERSION@}; +my $PREFIX = q{@LLVM_PREFIX@}; +my $BINDIR = q{@LLVM_BINDIR@}; +my $INCLUDEDIR = q{@LLVM_INCLUDEDIR@}; +my $LIBDIR = q{@LLVM_LIBDIR@}; +my $ARCH = lc(q{@ARCH@}); +my @TARGETS_BUILT = map { lc($_) } qw{@TARGETS_TO_BUILD@}; +#---- end autoconf values ---- + +#---- begin Makefile values ---- +my $CXXFLAGS = q{@LLVM_CXXFLAGS@}; +my $LDFLAGS = q{@LLVM_LDFLAGS@}; +my $CORE_IS_ARCHIVE = q{@CORE_IS_ARCHIVE@}; +#---- end Makefile values ---- + +sub usage; +sub fix_library_names (@); +sub expand_dependecies (@); +sub name_map_entries; + +# Parse our command-line arguments. +usage if @ARGV == 0; +my @components; +my $has_opt = 0; +my $want_libs = 0; +my $want_libnames = 0; +my $want_components = 0; +foreach my $arg (@ARGV) { + if ($arg =~ /^-/) { + if ($arg eq "--version") { + $has_opt = 1; print "$VERSION\n"; + } elsif ($arg eq "--prefix") { + $has_opt = 1; print "$PREFIX\n"; + } elsif ($arg eq "--bindir") { + $has_opt = 1; print "$BINDIR\n"; + } elsif ($arg eq "--includedir") { + $has_opt = 1; print "$INCLUDEDIR\n"; + } elsif ($arg eq "--libdir") { + $has_opt = 1; print "$LIBDIR\n"; + } elsif ($arg eq "--cxxflags") { + $has_opt = 1; print "-I$INCLUDEDIR $CXXFLAGS\n"; + } elsif ($arg eq "--ldflags") { + $has_opt = 1; print "-L$LIBDIR $LDFLAGS\n"; + } elsif ($arg eq "--libs") { + $has_opt = 1; $want_libs = 1; + } elsif ($arg eq "--libnames") { + $has_opt = 1; $want_libnames = 1; + } elsif ($arg eq "--components") { + $has_opt = 1; print join(' ', name_map_entries), "\n"; + } elsif ($arg eq "--targets-built") { + $has_opt = 1; print join(' ', @TARGETS_BUILT), "\n"; + } else { + usage(); + } + } else { + push @components, $arg; + } +} + +# If no options were specified, fail. +usage unless $has_opt; + +# If no components were specified, default to 'all'. +if (@components == 0) { + push @components, 'all'; +} + +# Handle any arguments which require building our dependency graph. +if ($want_libs || $want_libnames) { + my @libs = expand_dependecies(@components); + if ($want_libs) { + print join(' ', fix_library_names(@libs)), "\n"; + } + if ($want_libnames) { + print join(' ', @libs), "\n"; + } +} + +exit 0; + +#========================================================================== +# Support Routines +#========================================================================== + +sub usage { + print STDERR <<__EOD__; +Usage: llvm-config <OPTION>... [<COMPONENT>...] + +Get various configuration information needed to compile programs which use +LLVM. Typically called from 'configure' scripts. Examples: + llvm-config --cxxflags + llvm-config --ldflags + llvm-config --libs jitplus + +Options: + --version LLVM version. + --prefix Installation prefix. + --bindir Directory containing LLVM executables. + --includedir Directory containing LLVM headers. + --libdir Directory containing LLVM libraries. + --cxxflags C++ compiler flags for files that include LLVM headers. + --ldflags Linker flags. + --libs Libraries needed to link against LLVM components. + --libnames Bare library names for in-tree builds. + --components List of all possible components. + --targets-built List of all targets currently built. +Typical components: + all All LLVM libraries (default). + native A native-code backend for this platform, if any. + jitplus All libraries needed to use the LLVM JIT examples. +__EOD__ + exit(1); +} + +# Use -lfoo instead of libfoo.a whenever possible, and add directories to +# files which can't be found using -L. +sub fix_library_names (@) { + my @libs = @_; + my @result; + foreach my $lib (@libs) { + # Transform the bare library name appropriately. + my ($basename) = ($lib =~ /^lib([^.]*)\.a/); + if (defined $basename) { + push @result, "-l$basename"; + } else { + push @result, "$LIBDIR/$lib"; + } + } + return @result; +} + + +#========================================================================== +# Library Dependency Analysis +#========================================================================== +# Given a few human-readable library names, find all their dependencies +# and sort them into an order which the linker will like. If we packed +# our libraries into fewer archives, we could make the linker do much +# of this work for us. +# +# Libraries have two different types of names in this code: Human-friendly +# "component" names entered on the command-line, and the raw file names +# we use internally (and ultimately pass to the linker). +# +# To understand this code, you'll need a working knowledge of Perl 5, +# and possibly some quality time with 'man perlref'. + +sub load_dependencies; +sub build_name_map; +sub find_native_platform; +sub expand_names (@); +sub find_all_required_sets (@); +sub find_all_required_sets_helper ($$@); +sub maybe_fix_core (@); + +# Each "set" contains one or more libraries which must be included as a +# group (due to cyclic dependencies). Sets are represented as a Perl array +# reference pointing to a list of internal library names. +my @SETS; + +# Various mapping tables. +my %LIB_TO_SET_MAP; # Maps internal library names to their sets. +my %SET_DEPS; # Maps sets to a list of libraries they depend on. +my %NAME_MAP; # Maps human-entered names to internal names. + +# Have our dependencies been loaded yet? +my $DEPENDENCIES_LOADED = 0; + +# Given a list of human-friendly component names, translate them into a +# complete set of linker arguments. +sub expand_dependecies (@) { + my @libs = @_; + load_dependencies; + my @required_sets = find_all_required_sets(expand_names(@libs)); + my @sorted_sets = topologically_sort_sets(@required_sets); + + # Expand the library sets into libraries, and apply any + # platform-specific hackery. + my @result; + foreach my $set (@sorted_sets) { push @result, @{$set}; } + return maybe_fix_core(@result); +} + +# Load in the raw dependency data stored at the end of this file. +sub load_dependencies { + return if $DEPENDENCIES_LOADED; + $DEPENDENCIES_LOADED = 1; + while (<DATA>) { + # Parse our line. + my ($libs, $deps) = /^(^[^:]+): ?(.*)$/; + die "Malformed dependency data" unless defined $deps; + my @libs = split(' ', $libs); + my @deps = split(' ', $deps); + + # Record our dependency data. + my $set = \@libs; + push @SETS, $set; + foreach my $lib (@libs) { $LIB_TO_SET_MAP{$lib} = $set; } + $SET_DEPS{$set} = \@deps; + } + build_name_map; +} + +# Build a map converting human-friendly component names into internal +# library names. +sub build_name_map { + # Add entries for all the actual libraries. + foreach my $set (@SETS) { + foreach my $lib (sort @$set) { + my $short_name = $lib; + $short_name =~ s/^(lib)?LLVM([^.]*)\..*$/$2/; + $short_name =~ tr/A-Z/a-z/; + $NAME_MAP{$short_name} = [$lib]; + } + } + + # Add virtual entries. + $NAME_MAP{'native'} = find_native_platform; + $NAME_MAP{'jitplus'} = ['native', 'jit', 'bcreader', 'scalaropts']; + $NAME_MAP{'all'} = [name_map_entries]; # Must be last. +} + +# Figure our what native platform we should use, if any. +sub find_native_platform { + my %BUILT; + foreach my $target (@TARGETS_BUILT) { $BUILT{$target} = 1; } + if (defined $NAME_MAP{$ARCH} && defined $BUILT{$ARCH}) { + return [$ARCH]; + } else { + return []; + } +} + +# Get all the human-friendly component names. +sub name_map_entries { + load_dependencies; + return sort keys %NAME_MAP; +} + +# Map human-readable names to internal library names. +sub expand_names (@) { + my @names = @_; + my @result; + foreach my $name (@names) { + if (defined $LIB_TO_SET_MAP{$name}) { + # We've hit bottom: An actual library name. + push @result, $name; + } elsif (defined $NAME_MAP{$name}) { + # We've found a short name to expand. + push @result, expand_names(@{$NAME_MAP{$name}}); + } else { + print STDERR "llvm-config: unknown component name: $name\n"; + exit(1); + } + } + return @result; +} + +# Given a list of internal library names, return all sets of libraries which +# will need to be included by the linker (in no particular order). +sub find_all_required_sets (@) { + my @libs = @_; + my %sets_added; + my @result; + find_all_required_sets_helper(\%sets_added, \@result, @libs); + return @result; +} + +# Recursive closures are pretty broken in Perl, so we're going to separate +# this function from find_all_required_sets and pass in the state we need +# manually, as references. Yes, this is fairly unpleasant. +sub find_all_required_sets_helper ($$@) { + my ($sets_added, $result, @libs) = @_; + foreach my $lib (@libs) { + my $set = $LIB_TO_SET_MAP{$lib}; + next if defined $$sets_added{$set}; + $$sets_added{$set} = 1; + push @$result, $set; + find_all_required_sets_helper($sets_added, $result, @{$SET_DEPS{$set}}); + } +} + +# Print a list of sets, with a label. Used for debugging. +sub print_sets ($@) { + my ($label, @sets) = @_; + my @output; + foreach my $set (@sets) { push @output, join(',', @$set); } + print "$label: ", join(';', @output), "\n"; +} + +# Returns true if $lib is a key in $added. +sub has_lib_been_added ($$) { + my ($added, $lib) = @_; + return defined $$added{$LIB_TO_SET_MAP{$lib}}; +} + +# Returns true if all the dependencies of $set appear in $added. +sub have_all_deps_been_added ($$) { + my ($added, $set) = @_; + #print_sets(" Checking", $set); + #print_sets(" Wants", $SET_DEPS{$set}); + foreach my $lib (@{$SET_DEPS{$set}}) { + return 0 unless has_lib_been_added($added, $lib); + } + return 1; +} + +# Given a list of sets, topologically sort them using dependencies. +sub topologically_sort_sets (@) { + my @sets = @_; + my %added; + my @result; + SCAN: while (@sets) { # We'll delete items from @sets as we go. + #print_sets("So far", reverse(@result)); + #print_sets("Remaining", @sets); + for (my $i = 0; $i < @sets; ++$i) { + my $set = $sets[$i]; + if (have_all_deps_been_added(\%added, $set)) { + push @result, $set; + $added{$set} = 1; + #print "Removing $i.\n"; + splice(@sets, $i, 1); + next SCAN; # Restart our scan. + } + } + die "Can't find a library with no dependencies"; + } + return reverse(@result); +} + +# Nasty hack to work around the fact that LLVMCore changes file type on +# certain platforms. +sub maybe_fix_core (@) { + my @libs = @_; + my @result; + foreach my $lib (@libs) { + if ($lib eq "LLVMCore.o" && $CORE_IS_ARCHIVE) { + push @result, "libLLVMCore.a"; + } else { + push @result, $lib; + } + } + return @result; +} + +# Our library dependency data will be added after the '__END__' token, and will +# be read through the magic <DATA> filehandle. +__END__ |