X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Farchitecture.cpp;h=9662bbaa6f08e2dbcaeef2f9a75c9df77818b99d;hb=d1f9551e05c9d341149eb490e05b1465d3d6b711;hp=1f578af409f72ce367f5fb09ee0fa968e5020976;hpb=3585dea6eabf5f1565886bf09c2bdb2eee978912;p=builder.git diff --git a/source/architecture.cpp b/source/architecture.cpp index 1f578af..9662bba 100644 --- a/source/architecture.cpp +++ b/source/architecture.cpp @@ -1,56 +1,320 @@ -/* $Id$ - -This file is part of builder -Copyright © 2006-2007 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - +#include +#include +#include #include "architecture.h" #include "builder.h" +#include "executable.h" +#include "importlibrary.h" +#include "objectfile.h" +#include "sharedlibrary.h" +#include "staticlibrary.h" +#include "sysutils.h" using namespace std; using namespace Msp; -Architecture::Architecture(Builder &b, const string &n, bool a): - builder(b), - name(n), - native(a) -{ } +namespace { + +const char *types[] = +{ + "x86", + "arm", + "ppc", + 0 +}; + +const char *cpus[] = +{ + "i386", "x86", + "i486", "x86", + "pentium", "x86", + "pentiumpro", "x86", + "pentium2", "x86", + "pentium3", "x86", + "pentium4", "x86", + "core2", "x86", + "nehalem", "x86", + "k6", "x86", + "athlon", "x86", + "athlonxp", "x86", + "athlon64", "x86", + "armv5", "arm", + "armv6", "arm", + "armv7", "arm", + "armv7a", "arm", + 0 +}; + +const char *fpus[] = +{ + "387", "x86", + "sse", "x86", + "sse3", "x86", + "sse4.1", "x86", + "vfpv3", "arm", + "neon", "arm", + 0 +}; -void Architecture::set_tool(const string &t, const string &p) +const char *systems[] = { - tools[t]=p; + "linux", + "freebsd", + "darwin", + "windows", + "android", + 0 +}; + +const char *toolchains[] = +{ + "gnu", + "clang", + "msvc", + 0 +}; + +const char *aliases[] = +{ + "pc", "x86", + "x86_64", "x86-64", + "x64", "x86-64", + "amd64", "x86-64", + "i586", "pentium", + "i686", "pentiumpro", + "corei7", "nehalem", + "win32", "windows-32", + "win64", "windows-64", + "power macintosh", "ppc", + "armeabi", "arm", + "v7a", "armv7a", + "gcc", "gnu", + "mingw", "windows-gnu", + 0 +}; + } -std::string Architecture::get_tool(const string &t) const +Architecture::Architecture(Builder &b, const string &spec): + builder(b) { - StringMap::const_iterator i=tools.find(t); - if(i!=tools.end()) + if(spec.empty()) { - if(i->second[0]=='-') - return prefix+i->second; + parse_specification(get_system_type()); + // We really only want to set type for the default arch + cpu.clear(); + bits = sizeof(void *)*numeric_limits::digits; + native = true; + } + else + { + parse_specification(spec); + const Architecture &native_arch = builder.get_native_arch(); + if(type.empty()) + type = native_arch.type; + if(system.empty()) + system = native_arch.system; + if(!bits) + { + if(type==native_arch.type) + bits = native_arch.bits; + else + bits = 32; + } + + if(type!=native_arch.type || system!=native_arch.system) + cross_prefix = format("%s-%s", type, system); + else if(bits==native_arch.bits) + native = true; + } + + if(toolchain.empty()) + { + if((system=="darwin" || system=="freebsd") && builder.get_vfs().find_binary("clang")) + toolchain = "clang"; + else if(system=="windows" && native) + toolchain = "msvc"; else - return i->second; + toolchain = "gnu"; } - if(!native) + name = type; + if(!cpu.empty()) + name += format("-%s", cpu); + if(!fpu.empty()) + name += format("-%s", fpu); + name += format("-%d-%s-%s", bits, system, toolchain); + + if(system=="windows") { - const Architecture &native_arch=builder.get_native_arch(); - return prefix+"-"+native_arch.get_tool(t); + add_pattern("%.dll"); + if(toolchain=="msvc") + { + add_pattern("%.obj"); + add_pattern("%.lib"); + add_pattern("%_static.lib"); + } + else + { + add_pattern("%.o"); + add_pattern("lib%.dll"); + add_pattern("lib%.dll.a"); + add_pattern("lib%.a"); + } + add_pattern("%.exe"); } else - throw KeyError("Unknown tool"); + { + add_pattern("%.o"); + if(system=="darwin") + add_pattern("lib%.dylib"); + else + add_pattern("lib%.so"); + add_pattern("lib%.a"); + add_pattern("%"); + } } +bool Architecture::match_name(const string &pattern, unsigned *quality) const +{ + bool negate = (pattern[0]=='!'); + vector parts = split(pattern.substr(negate), "-"); + resolve_aliases(parts); + for(const string &p: parts) + { + if((p=="32" && bits==32) || (p=="64" && bits==64)) + ; + else if(p!=type && p!=cpu && p!=fpu && p!=system && p!=toolchain) + { + if(quality) + *quality = 0; + return negate; + } + } -Architecture::Loader::Loader(Architecture &a): - arch(a) + if(quality) + *quality = parts.size(); + return !negate; +} + +string Architecture::best_match(const vector &names) const +{ + string best; + unsigned best_quality = 0; + for(const string &n: names) + { + unsigned quality; + if(match_name(n, &quality)) + if(quality>best_quality) + { + best = n; + best_quality = quality; + } + } + + return best; +} + +template +void Architecture::add_pattern(const string &pat) { - add("prefix", &Architecture::prefix); - add("tool", &Loader::tool); + filename_patterns[typeid(T).name()].push_back(Pattern(pat)); +} + +void Architecture::resolve_aliases(vector &parts) +{ + for(unsigned i=0; i rparts = split(replace, "-"); + parts[i] = rparts[0]; + parts.insert(parts.begin()+i+1, rparts.begin()+1, rparts.end()); + i += rparts.size()-1; + } + else + parts[i] = replace; + } + } } -void Architecture::Loader::tool(const string &t, const string &p) +void Architecture::parse_specification(const string &spec) +{ + vector parts = split(spec, "-"); + resolve_aliases(parts); + for(const string &p: parts) + { + bool ok = false; + + for(unsigned j=0; (!ok && types[j]); ++j) + if(p==types[j]) + { + if(!type.empty() && p!=type) + throw invalid_argument("Conflicting type specification"); + type = p; + ok = true; + } + + for(unsigned j=0; (!ok && cpus[j]); j+=2) + if(p==cpus[j]) + { + if(type.empty()) + type = cpus[j+1]; + else if(cpus[j+1]!=type) + throw invalid_argument("Conflicting CPU specification"); + cpu = p; + ok = true; + } + + for(unsigned j=0; (!ok && fpus[j]); j+=2) + if(p==fpus[j]) + { + if(fpus[j+1]!=type) + throw invalid_argument("Conflicting FPU specification"); + fpu = p; + ok = true; + } + + for(unsigned j=0; (!ok && systems[j]); ++j) + if(p==systems[j]) + { + system = p; + ok = true; + } + + for(unsigned j=0; (!ok && toolchains[j]); ++j) + if(p==toolchains[j]) + { + toolchain = p; + ok = true; + } + + if(!ok && (p=="32" || p=="64")) + { + bits = lexical_cast(p); + ok = true; + } + + if(!ok) + throw invalid_argument("Unrecognized part in arch specification: "+p); + } +} + + +Architecture::Loader::Loader(Architecture &a): + DataFile::ObjectLoader(a) { - arch.tools[t]=p; + add("prefix", &Architecture::cross_prefix); }