Add more recognized architectures

Aliases can now resolve to multiple parts, so words like x86_64 or win32
can do the right thing.

The pc type was changed to x86, because that more accurately describes
the processor archetype.

diff --git a/source/architecture.cpp b/source/architecture.cpp
index 847711e351c3c7fc47ff93b60494e539f8c4c4b3..a9434986a91170a3de3ef4c7e6462b7b2ee1c911 100644 (file)
--- a/source/architecture.cpp
+++ b/source/architecture.cpp
@@ -14,7 +14,7 @@ namespace {
 
 const char *types[] =
 {
-       "pc",
+       "x86",
        "arm",
        "ppc",
        0
@@ -22,19 +22,23 @@ const char *types[] =
 
 const char *cpus[] =
 {
-       "i386",       "pc",
-       "i486",       "pc",
-       "pentium",    "pc",
-       "pentiumpro", "pc",
-       "pentium2",   "pc",
-       "pentium3",   "pc",
-       "pentium4",   "pc",
-       "core2",      "pc",
-       "k6",         "pc",
-       "athlon",     "pc",
-       "athlonxp",   "pc",
-       "athlon64",   "pc",
+       "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
 };
 
@@ -50,12 +54,17 @@ const char *systems[] =
 
 const char *aliases[] =
 {
-       "x86",   "pc",
-       "i586",  "pentium",
-       "i686",  "pentiumpro",
-       "x86_64", "athlon64",
-       "win32", "windows",
+       "pc",              "x86",
+       "x86_64",          "x86-64",
+       "amd64",           "x86-64",
+       "i586",            "pentium",
+       "i686",            "pentiumpro",
+       "corei7",          "nehalem",
+       "win32",           "windows-32",
+       "win64",           "windows-64",
        "power macintosh", "ppc",
+       "armeabi",         "arm",
+       "v7a",             "armv7a",
        0
 };
 
@@ -134,65 +143,84 @@ bool Architecture::match_name(const string &pattern) const
 {
        bool negate = (pattern[0]=='!');
        vector<string> parts = split(pattern.substr(negate), "-");
+       resolve_aliases(parts);
        for(vector<string>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
        {
-               string part = resolve_alias(*i);
-               if((part=="32" && bits==32) || (part=="64" && bits==64))
+               if((*i=="32" && bits==32) || (*i=="64" && bits==64))
                        ;
-               else if(part!=type && part!=cpu && part!=system)
+               else if(*i!=type && *i!=cpu && *i!=system)
                        return negate;
        }
        return !negate;
 }
 
-string Architecture::resolve_alias(const string &part) const
+void Architecture::resolve_aliases(vector<string> &parts)
 {
-       for(unsigned j=0; aliases[j]; j+=2)
-               if(part==aliases[j])
-                       return aliases[j+1];
+       for(unsigned i=0; i<parts.size(); ++i)
+       {
+               const string &part = parts[i];
+               const char *replace = 0;
+               for(unsigned j=0; (!replace && aliases[j]); j+=2)
+                       if(part==aliases[j])
+                               replace = aliases[j+1];
+
+               if(replace)
+               {
+                       bool has_dash = false;
+                       for(const char *c=replace; (!has_dash && *c); ++c)
+                               has_dash = (*c=='-');
 
-       return part;
+                       if(has_dash)
+                       {
+                               vector<string> 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::parse_specification(const string &spec)
 {
        vector<string> parts = split(spec, "-");
+       resolve_aliases(parts);
        for(vector<string>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
        {
-               string part = resolve_alias(*i);
-
                bool ok = false;
 
                for(unsigned j=0; (!ok && types[j]); ++j)
-                       if(part==types[j])
+                       if(*i==types[j])
                        {
-                               if(!type.empty() && part!=type)
+                               if(!type.empty() && *i!=type)
                                        throw invalid_argument("Conflicting type specification");
-                               type = part;
+                               type = *i;
                                ok = true;
                        }
 
                for(unsigned j=0; (!ok && cpus[j]); j+=2)
-                       if(part==cpus[j])
+                       if(*i==cpus[j])
                        {
                                if(type.empty())
                                        type = cpus[j+1];
                                else if(cpus[j+1]!=type)
                                        throw invalid_argument("Conflicting CPU specification");
-                               cpu = part;
+                               cpu = *i;
                                ok = true;
                        }
 
                for(unsigned j=0; (!ok && systems[j]); ++j)
-                       if(part==systems[j])
+                       if(*i==systems[j])
                        {
-                               system = part;
+                               system = *i;
                                ok = true;
                        }
 
-               if(!ok && (part=="32" || part=="64"))
+               if(!ok && (*i=="32" || *i=="64"))
                {
-                       bits = lexical_cast<unsigned>(part);
+                       bits = lexical_cast<unsigned>(*i);
                        ok = true;
                }
 

diff --git a/source/architecture.h b/source/architecture.h
index cec397f8a29e1968a598d83abc949088a64d51ed..d84173e67029f2bcd7a74a230dc6a7ee388dd090 100644 (file)
--- a/source/architecture.h
+++ b/source/architecture.h
@@ -54,7 +54,7 @@ public:
        const PatternList &get_executable_patterns() const { return executable_patterns; }
 
 private:
-       std::string resolve_alias(const std::string &) const;
+       static void resolve_aliases(std::vector<std::string> &);
        void parse_specification(const std::string &);
 };
 

diff --git a/source/gnucompiler.cpp b/source/gnucompiler.cpp
index 051722832ea66402e515733fb51cd5c6ad78aa8e..6daa99d81a565c482c05f6a49127986d0a457ead 100644 (file)
--- a/source/gnucompiler.cpp
+++ b/source/gnucompiler.cpp
@@ -15,6 +15,17 @@
 using namespace std;
 using namespace Msp;
 
+namespace {
+
+const char *cpus[] =
+{
+       "athlonxp", "athlon-xp",
+       "armv7a",   "armv7-a",
+       0
+};
+
+}
+
 GnuCompiler::GnuCompiler(Builder &b, const Architecture &a, const string &t, const FS::Path &sysroot):
        Tool(b, a, t)
 {
@@ -165,9 +176,17 @@ Task *GnuCompiler::run(const Target &target) const
        if(architecture->is_native() && architecture->get_bits()!=native_arch.get_bits())
                argv.push_back(format("-m%d", architecture->get_bits()));
 
-       const string &cpu = architecture->get_cpu();
+       string cpu = architecture->get_cpu();
        if(!cpu.empty())
+       {
+               for(unsigned i=0; cpus[i]; i+=2)
+                       if(cpu==cpus[i])
+                       {
+                               cpu = cpus[i+1];
+                               break;
+                       }
                argv.push_back("-march="+cpu);
+       }
 
        FS::Path obj_path = object.get_path();
        FS::Path src_path = object.get_source().get_path();