| #include "libslang.h" |
| #include "slang_rs_reflect_utils.h" |
| |
| #include <assert.h> |
| #include <getopt.h> |
| |
| #include <cstring> |
| #include <cstdlib> |
| #include <cstdio> |
| #include <iomanip> |
| #include <iostream> |
| #include <vector> |
| |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| #include <sys/wait.h> |
| |
| using namespace std; |
| |
| #define ERR_NO_INPUT_FILE "no input file" |
| |
| #define NOTE(x) cerr << "note: " NOTE_ ## x << endl |
| #define WARN(x) cerr << "warning: " WARN_ ## x << endl |
| #define WARN1(x, v1) cerr << "warning: " WARN_ ## x(v1) << endl |
| #define WARN2(x, v1, v2) cerr << "warning: " WARN_ ## x(v1, v2) << endl |
| |
| #define NOTE_MULTIPLE_INPUT_FILES "multiple input files detected: Will enforce ODR (One Definition Rule) during reflection." |
| |
| #define WARN_UNKNOWN_CPU(v1) "the given CPU " << (v1) << " cannot be recognized, but we'll force passing it to Slang compiler" |
| |
| #define WARN_MISMATCH_CPU_TARGET_ARCH(v1, v2) \ |
| "CPU (target: " << (v1) << ") you selected doesn't match the target of enable features you specified or the triple string you given (" << (v2) << ")" |
| |
| #define WARN_MISMATCH_FEATURE_TARGET_ARCH(v1, v2) \ |
| "Feature (target: " << (v1) << ") you selected doesn't match the target of CPU you specified or the triple string you given (" << (v2) << ")" |
| |
| /* List of all support target, will look like "ArchARM" */ |
| #define MK_TARGET_ARCH(target) Arch ## target |
| |
| typedef enum { |
| ArchNone, |
| #define DEF_SUPPORT_TARGET(target, name, default_triple) \ |
| MK_TARGET_ARCH(target), |
| # include "target.inc" |
| |
| MaxTargetArch |
| } TargetArchEnum; |
| |
| typedef struct { |
| TargetArchEnum Arch; |
| const char* Name; |
| const char* DefaultTriple; |
| } TargetArch; |
| |
| static const TargetArch TargetArchTable[] = { |
| { ArchNone, "none", "unknown-unknown-linux" }, |
| #define DEF_SUPPORT_TARGET(target, name, default_triple) \ |
| { MK_TARGET_ARCH(target), name, default_triple }, |
| # include "target.inc" |
| }; |
| |
| #if defined(__arm__) |
| # define HOST_ARCH MK_TARGET_ARCH(X86) |
| #elif defined(__i386__) |
| # define HOST_ARCH MK_TARGET_ARCH(ARM) |
| #elif defined(__x86_64__) |
| # define HOST_ARCH MK_TARGET_ARCH(X64) |
| #else |
| # error "We can not find default triple string for your host machine, please define it by yourself via option '--triple' or '-t'" |
| #endif |
| |
| #define DEFAULT_TARGET_TRIPLE_STRING TargetArchTable[HOST_ARCH].DefaultTriple |
| |
| /* Lists of all target features, will look like "{Target}FeatureNEON" */ |
| #define MK_TARGET_FEATURE(target, id) target ## id |
| typedef enum { |
| FeatureNone = 0, |
| #define DEF_TARGET_FEATURE(target, id, key, description) \ |
| MK_TARGET_FEATURE(target, id), |
| |
| #define HOOK_TARGET_FIRST_FEATURE(target, id, key, description) \ |
| target ## FeatureStart, \ |
| MK_TARGET_FEATURE(target, id) = target ## FeatureStart, |
| |
| # include "target.inc" |
| |
| MaxTargetFeature |
| } TargetFeatureEnum; |
| |
| /* Feature as bits using in {Target}TargetCPU, will look like "X{Target}FeatureNEON" */ |
| #define MK_TARGET_FEATURE_BIT(target, id) X ## target ## id |
| typedef enum { |
| XFeatureNone = 0, |
| #define DEF_TARGET_FEATURE(target, id, key, description) \ |
| MK_TARGET_FEATURE_BIT(target, id) = 1 << (MK_TARGET_FEATURE(target, id) - target ## FeatureStart), |
| # include "target.inc" |
| |
| XMaxTargetFeature |
| } TargetFeatureBit; |
| |
| typedef struct { |
| TargetArchEnum Arch; |
| TargetFeatureEnum Key; |
| TargetFeatureBit Bit; |
| const char* Name; |
| const char* Desc; |
| } TargetFeature; |
| |
| /* Should be 1-1 mapping with TargetFeatureEnum */ |
| static const TargetFeature TargetFeatureTable[] = { |
| { ArchNone, FeatureNone, XFeatureNone, "none", "Empty feature" }, /* FeatureNone */ |
| #define DEF_TARGET_FEATURE(target, id, key, description) \ |
| { MK_TARGET_ARCH(target), MK_TARGET_FEATURE(target, id), MK_TARGET_FEATURE_BIT(target, id), key, description }, |
| # include "target.inc" |
| }; |
| |
| typedef struct { |
| TargetArchEnum Arch; |
| const char* Name; |
| const char* Desc; |
| unsigned int FeatureEnabled; |
| } TargetCPU; |
| |
| /* Sorted by CPU name such that we can call bsearch() to quickly retain the CPU entry corresponding to the name */ |
| #define E(feature) MK_TARGET_FEATURE_BIT(ARM, feature) |
| static const TargetCPU TargetCPUTable[] = { |
| { MK_TARGET_ARCH(ARM), "arm1020e", "Select the arm1020e processor", E(ArchV5TE) }, |
| { MK_TARGET_ARCH(ARM), "arm1020t", "Select the arm1020t processor", E(ArchV5T) }, |
| { MK_TARGET_ARCH(ARM), "arm1022e", "Select the arm1022e processor", E(ArchV5TE) }, |
| { MK_TARGET_ARCH(ARM), "arm10e", "Select the arm10e processor", E(ArchV5TE) }, |
| { MK_TARGET_ARCH(ARM), "arm10tdmi", "Select the arm10tdmi processor", E(ArchV5T) }, |
| { MK_TARGET_ARCH(ARM), "arm1136j-s", "Select the arm1136j-s processor", E(ArchV6) }, |
| { MK_TARGET_ARCH(ARM), "arm1136jf-s", "Select the arm1136jf-s processor", E(ArchV6) | E(FeatureVFP2) }, |
| { MK_TARGET_ARCH(ARM), "arm1156t2-s", "Select the arm1156t2-s processor", E(ArchV6T2) | E(FeatureThumb2) }, |
| { MK_TARGET_ARCH(ARM), "arm1156t2f-s", "Select the arm1156t2f-s processor", E(ArchV6T2) | E(FeatureThumb2) | E(FeatureVFP2) }, |
| { MK_TARGET_ARCH(ARM), "arm1176jz-s", "Select the arm1176jz-s processor", E(ArchV6) }, |
| { MK_TARGET_ARCH(ARM), "arm1176jzf-s", "Select the arm1176jzf-s processor", E(ArchV6) | E(FeatureVFP2) }, |
| { MK_TARGET_ARCH(ARM), "arm710t", "Select the arm710t processor", E(ArchV4T) }, |
| { MK_TARGET_ARCH(ARM), "arm720t", "Select the arm720t processor", E(ArchV4T) }, |
| { MK_TARGET_ARCH(ARM), "arm7tdmi", "Select the arm7tdmi processor", E(ArchV4T) }, |
| { MK_TARGET_ARCH(ARM), "arm7tdmi-s", "Select the arm7tdmi-s processor", E(ArchV4T) }, |
| { MK_TARGET_ARCH(ARM), "arm8", "Select the arm8 processor", XFeatureNone }, |
| { MK_TARGET_ARCH(ARM), "arm810", "Select the arm810 processor", XFeatureNone }, |
| { MK_TARGET_ARCH(ARM), "arm9", "Select the arm9 processor", E(ArchV4T) }, |
| { MK_TARGET_ARCH(ARM), "arm920", "Select the arm920 processor", E(ArchV4T) }, |
| { MK_TARGET_ARCH(ARM), "arm920t", "Select the arm920t processor", E(ArchV4T) }, |
| { MK_TARGET_ARCH(ARM), "arm922t", "Select the arm922t processor", E(ArchV4T) }, |
| { MK_TARGET_ARCH(ARM), "arm926ej-s", "Select the arm926ej-s processor", E(ArchV5TE) }, |
| { MK_TARGET_ARCH(ARM), "arm940t", "Select the arm940t processor", E(ArchV4T) }, |
| { MK_TARGET_ARCH(ARM), "arm946e-s", "Select the arm946e-s processor", E(ArchV5TE) }, |
| { MK_TARGET_ARCH(ARM), "arm966e-s", "Select the arm966e-s processor", E(ArchV5TE) }, |
| { MK_TARGET_ARCH(ARM), "arm968e-s", "Select the arm968e-s processor", E(ArchV5TE) }, |
| { MK_TARGET_ARCH(ARM), "arm9e", "Select the arm9e processor", E(ArchV5TE) }, |
| { MK_TARGET_ARCH(ARM), "arm9tdmi", "Select the arm9tdmi processor", E(ArchV4T) }, |
| { MK_TARGET_ARCH(ARM), "cortex-a8", "Select the cortex-a8 processor", E(ArchV7A) | E(FeatureThumb2) | E(FeatureNEON) }, |
| { MK_TARGET_ARCH(ARM), "cortex-a9", "Select the cortex-a9 processor", E(ArchV7A) | E(FeatureThumb2) | E(FeatureNEON) }, |
| { MK_TARGET_ARCH(ARM), "ep9312", "Select the ep9312 processor", E(ArchV4T) }, |
| { MK_TARGET_ARCH(ARM), "generic", "Select the generic processor", XFeatureNone }, |
| { MK_TARGET_ARCH(ARM), "iwmmxt", "Select the iwmmxt processor", E(ArchV5TE) }, |
| { MK_TARGET_ARCH(ARM), "mpcore", "Select the mpcore processor", E(ArchV6) | E(FeatureVFP2) }, |
| { MK_TARGET_ARCH(ARM), "mpcorenovfp", "Select the mpcorenovfp processor", E(ArchV6) }, |
| { MK_TARGET_ARCH(ARM), "strongarm", "Select the strongarm processor", XFeatureNone }, |
| { MK_TARGET_ARCH(ARM), "strongarm110", "Select the strongarm110 processor", XFeatureNone }, |
| { MK_TARGET_ARCH(ARM), "strongarm1100", "Select the strongarm1100 processor", XFeatureNone }, |
| { MK_TARGET_ARCH(ARM), "strongarm1110", "Select the strongarm1110 processor", XFeatureNone }, |
| { MK_TARGET_ARCH(ARM), "xscale", "Select the xscale processor", MK_TARGET_FEATURE_BIT(ARM, ArchV5TE) } |
| }; |
| #undef E |
| static int CompareCPUName(const void* a, const void* b) { |
| return strcasecmp(((TargetCPU*) a)->Name, ((TargetCPU*) b)->Name); |
| } |
| #define NUM_TARGET_CPU (sizeof(TargetCPUTable) / sizeof(TargetCPU)) |
| |
| static struct option* SlangOpts = NULL; |
| |
| static const char* CPUString; |
| static const TargetCPU* CPU; |
| static const char* TripleString; |
| static TargetFeatureEnum EnableFeatureValue, DisableFeatureValue; |
| static SlangCompilerOutputTy OutputFileType; |
| static const char* JavaReflectionPackageName; |
| |
| static const char* JavaReflectionPathName; |
| static const char* OutputPathName; |
| |
| static std::vector<std::string> IncludePaths; |
| |
| static std::string* InputFileNames; |
| static std::string* OutputFileNames; |
| |
| // Where to store the bc file. |
| // possible values: |
| // ar: packed as apk resource |
| // jc: encoded in Java code. |
| static slang::BitCodeStorageType BitCodeStorage(slang::BCST_APK_RESOURCE); |
| |
| static bool Verbose; |
| static const char* FeatureEnabledList[MaxTargetFeature + 1]; |
| static int AllowRSPrefix = 0; |
| static int Externalize = 0; |
| static int NoLink = 1; |
| |
| /* Construct the command options table used in ParseOption::getopt_long */ |
| static void ConstructCommandOptions() { |
| /* Basic slang command option */ |
| static struct option BasicSlangOpts[] = { |
| { "allow-rs-prefix", no_argument, &AllowRSPrefix, 1 }, |
| { "externalize", no_argument, &Externalize, 1 }, |
| { "no-link", no_argument, &NoLink, 1 }, |
| |
| { "emit-llvm", no_argument, (int*) &OutputFileType, SlangCompilerOutput_LL }, |
| { "emit-bc", no_argument, (int*) &OutputFileType, SlangCompilerOutput_Bitcode }, |
| { "emit-asm", no_argument, NULL, 'S' }, |
| { "emit-obj", no_argument, NULL, 'c' }, |
| { "emit-nothing", no_argument, (int*) &OutputFileType, SlangCompilerOutput_Nothing }, |
| |
| { "help", no_argument, NULL, 'h' }, /* -h */ |
| { "verbose", no_argument, NULL, 'v' }, /* -v */ |
| |
| { "output-obj-path", required_argument, NULL, 'o' }, /* -o */ |
| { "cpu", required_argument, NULL, 'u' }, /* -u */ |
| { "triple", required_argument, NULL, 't' }, /* -t */ |
| |
| { "output-java-reflection-class", required_argument, NULL, 'j'}, /* -j */ |
| { "output-java-reflection-path", required_argument, NULL, 'p'}, /* -p */ |
| |
| { "include-path", required_argument, NULL, 'I'}, /* -I */ |
| { "bitcode-storage", required_argument, NULL, 's'}, /* -s */ |
| }; |
| |
| const int NumberOfBasicOptions = sizeof(BasicSlangOpts) / sizeof(struct option); |
| |
| SlangOpts = new struct option [ NumberOfBasicOptions + MaxTargetFeature * 2 /* for --enable-feature and --disable-feature */ ]; |
| |
| /* Fill SlangOpts with basic options */ |
| memcpy(SlangOpts, BasicSlangOpts, sizeof(BasicSlangOpts)); |
| |
| int i = NumberOfBasicOptions; |
| /* Add --enable-TARGET_FEATURE option into slang command option */ |
| #define DEF_TARGET_FEATURE(target, id, key, description) \ |
| SlangOpts[i].name = "enable-" key; \ |
| SlangOpts[i].has_arg = optional_argument; \ |
| SlangOpts[i].flag = (int*) &EnableFeatureValue; \ |
| SlangOpts[i].val = target ## id; \ |
| i++; |
| # include "target.inc" |
| |
| /* Add --disable-TARGET_FEATURE option into slang command option */ |
| #define DEF_TARGET_FEATURE(target, id, key, description) \ |
| SlangOpts[i].name = "disable-" key; \ |
| SlangOpts[i].has_arg = optional_argument; \ |
| SlangOpts[i].flag = (int*) &DisableFeatureValue; \ |
| SlangOpts[i].val = target ## id; \ |
| i++; |
| # include "target.inc" |
| |
| /* NULL-terminated the SlangOpts */ |
| memset(&SlangOpts[i], 0, sizeof(struct option)); |
| |
| return; |
| } |
| |
| |
| static void Usage(const char* CommandName); |
| |
| extern char *optarg; |
| extern int optind; |
| extern int optopt; |
| extern int opterr; |
| static int FileCount; |
| |
| static int AddOutputFileSuffix(std::string &pathFile) { |
| switch (OutputFileType) { |
| case SlangCompilerOutput_Assembly: |
| pathFile += ".S"; |
| break; |
| case SlangCompilerOutput_LL: |
| pathFile += ".ll"; |
| break; |
| case SlangCompilerOutput_Obj: |
| pathFile += ".o"; |
| break; |
| |
| case SlangCompilerOutput_Nothing: |
| return 0; //strcpy(OutputFileNames[count], "/dev/null"); |
| |
| case SlangCompilerOutput_Bitcode: |
| default: |
| pathFile += ".bc"; |
| break; |
| } |
| return 1; |
| } |
| |
| static bool ParseOption(int Argc, char** Argv) { |
| assert(SlangOpts != NULL && "Slang command options table was not initialized!"); |
| |
| /* Set default value to option */ |
| CPU = NULL; |
| TripleString = DEFAULT_TARGET_TRIPLE_STRING; |
| EnableFeatureValue = DisableFeatureValue = FeatureNone; |
| OutputFileType = SlangCompilerOutput_Default; |
| JavaReflectionPackageName = NULL; |
| |
| JavaReflectionPathName = NULL; |
| OutputPathName = NULL; |
| |
| IncludePaths.clear(); |
| |
| InputFileNames = NULL; |
| OutputFileNames = NULL; |
| |
| Verbose = false; |
| FeatureEnabledList[0] = NULL; |
| |
| int ch; |
| |
| unsigned int FeatureEnableBits = 0; |
| unsigned int FeatureDisableBits = 0; |
| #define ENABLE_FEATURE(x) \ |
| FeatureEnableBits |= (x) |
| #define DISABLE_FEATURE(x) \ |
| FeatureDisableBits |= (x) |
| TargetArchEnum ExpectedArch = ArchNone; |
| |
| /* Turn off the error message output by getopt_long */ |
| opterr = 0; |
| |
| while((ch = getopt_long(Argc, Argv, "Schvo:u:t:j:p:I:s:", SlangOpts, NULL)) != -1) { |
| switch(ch) { |
| case 'S': |
| OutputFileType = SlangCompilerOutput_Assembly; |
| break; |
| |
| case 'c': |
| OutputFileType = SlangCompilerOutput_Obj; |
| break; |
| |
| case 'o': |
| OutputPathName = optarg; |
| break; |
| |
| case 'j': |
| JavaReflectionPackageName = optarg; |
| break; |
| |
| case 'p': |
| JavaReflectionPathName = optarg; |
| break; |
| |
| case 'I': |
| IncludePaths.push_back(optarg); |
| break; |
| |
| case 's': |
| if (!std::strcmp(optarg, "ar")) { |
| BitCodeStorage = slang::BCST_APK_RESOURCE; |
| } else if (!std::strcmp(optarg, "jc")) { |
| BitCodeStorage = slang::BCST_JAVA_CODE; |
| } else { |
| cerr << "Error: bit code storage (-s) should be 'ar' or 'jc', saw " |
| << optarg << endl; |
| return false; |
| } |
| break; |
| |
| case 'u': |
| { |
| CPUString = optarg; |
| const TargetCPU SearchCPU = { ArchNone, CPUString, NULL, XFeatureNone }; |
| CPU = (TargetCPU*) bsearch(&SearchCPU, TargetCPUTable, sizeof(TargetCPUTable) / sizeof(TargetCPU), sizeof(TargetCPU), CompareCPUName); |
| if(CPU == NULL) { |
| WARN1(UNKNOWN_CPU, SearchCPU.Name); |
| } else { |
| CPUString = CPU->Name; |
| |
| if(ExpectedArch == ArchNone) |
| ExpectedArch = CPU->Arch; |
| else if(ExpectedArch != CPU->Arch) { |
| WARN2(MISMATCH_CPU_TARGET_ARCH, TargetArchTable[CPU->Arch].Name, TargetArchTable[ExpectedArch].Name); |
| break; |
| } |
| |
| /* Get CPU Feature and enable its available feature */ |
| FeatureEnableBits |= CPU->FeatureEnabled; |
| } |
| } |
| break; |
| |
| case 't': |
| TripleString = optarg; |
| break; |
| |
| case 'h': |
| Usage(Argv[0]); |
| return false; |
| break; |
| |
| case 'v': |
| Verbose = true; |
| break; |
| |
| case 0: |
| { |
| if(EnableFeatureValue != FeatureNone || DisableFeatureValue != FeatureNone) { |
| bool IsDisable = (DisableFeatureValue != FeatureNone); |
| const TargetFeature* FeatureSelected = &TargetFeatureTable[ ((IsDisable) ? DisableFeatureValue : EnableFeatureValue) ]; |
| assert(FeatureSelected != NULL && "Unexpected target feature! (not presented in table but parsed!?)"); |
| |
| if(ExpectedArch == ArchNone) |
| ExpectedArch = FeatureSelected->Arch; |
| else if(FeatureSelected->Arch != ExpectedArch) { |
| WARN2(MISMATCH_FEATURE_TARGET_ARCH, TargetArchTable[FeatureSelected->Arch].Name, TargetArchTable[ExpectedArch].Name); |
| break; |
| } |
| |
| if(optarg != NULL && atoi(optarg) == 0) |
| IsDisable = !IsDisable; |
| |
| if(IsDisable) |
| DISABLE_FEATURE(FeatureSelected->Bit); |
| else |
| ENABLE_FEATURE(FeatureSelected->Bit); |
| } |
| } |
| break; |
| |
| default: |
| cerr << "Unknown option: " << Argv[optind - 1] << endl; |
| return false; |
| break; |
| } |
| } |
| #undef ENABLE_FEATURE |
| #undef DISABLE_FEATURE |
| |
| int CurFeatureEnableListIdx = 0; |
| /* Add the enable/disable feature string to */ |
| switch(ExpectedArch) { |
| case ArchNone: |
| ExpectedArch = HOST_ARCH; |
| break; |
| |
| #define DEF_TARGET_FEATURE(target, id, key, description) \ |
| if(FeatureDisableBits & MK_TARGET_FEATURE_BIT(target, id)) \ |
| FeatureEnabledList[ CurFeatureEnableListIdx++ ] = "-" key; \ |
| else if(FeatureEnableBits & MK_TARGET_FEATURE_BIT(target, id)) \ |
| FeatureEnabledList[ CurFeatureEnableListIdx++ ] = "+" key; |
| #define HOOK_TARGET_FIRST_FEATURE(target, id, key, description) \ |
| case Arch ## target: \ |
| /* Fix target triple */ \ |
| if(TripleString == DEFAULT_TARGET_TRIPLE_STRING) \ |
| TripleString = TargetArchTable[MK_TARGET_ARCH(target)].DefaultTriple; \ |
| DEF_TARGET_FEATURE(target, id, key, description) |
| #define HOOK_TARGET_LAST_FEATURE(target, id, key, description) \ |
| DEF_TARGET_FEATURE(target, id, key, description) \ |
| FeatureEnabledList[ CurFeatureEnableListIdx++ ] = NULL; /* null-terminator */ \ |
| break; |
| #include "target.inc" |
| |
| default: |
| assert(false && "Unknown / Unsupported CPU architecture"); |
| break; |
| } |
| |
| Argc -= optind; |
| if(Argc <= 0) { |
| cerr << Argv[0] << ": "ERR_NO_INPUT_FILE << endl; |
| return false; |
| } |
| |
| if(Argc > 1) { |
| NOTE(MULTIPLE_INPUT_FILES); |
| } |
| |
| |
| FileCount = Argc; |
| InputFileNames = new std::string[FileCount]; |
| OutputFileNames = new std::string[FileCount]; |
| int count; |
| for (count = 0; count < FileCount; count++) { |
| InputFileNames[count].assign(Argv[optind + count]); |
| |
| if ( OutputPathName && !strcmp(OutputPathName, "-") ) { |
| OutputFileNames[count].assign("stdout"); |
| continue; |
| } |
| |
| std::string _outF; |
| if (OutputPathName) { |
| _outF.assign(OutputPathName); |
| if (_outF[_outF.length()-1] != '/') { |
| _outF += "/"; |
| } |
| } |
| _outF += slang::RSSlangReflectUtils::BCFileNameFromRSFileName( |
| InputFileNames[count].c_str()); |
| |
| int status = AddOutputFileSuffix(_outF); |
| if (status < 0) { |
| return false; |
| } else if (!status) { |
| OutputFileNames[count].assign("/dev/null"); |
| } else { |
| OutputFileNames[count].assign(_outF); |
| } |
| } |
| |
| if(Verbose) { |
| for (count = 0; count < FileCount; count++) { |
| cout << "Input: " << InputFileNames[count] << endl; |
| } |
| |
| if(CPU != NULL) |
| cout << "Use CPU: " << CPU->Name << endl; |
| cout << "Use triple string: " << TripleString << endl; |
| cout << "Expected architecture: " << TargetArchTable[ExpectedArch].Name << endl; |
| |
| cout << "Enable target feature: " << endl; |
| for(int i=0;FeatureEnabledList[i]!=NULL;i++) |
| if(*FeatureEnabledList[i] == '+') |
| cout << "\t" << &FeatureEnabledList[i][1] << endl; |
| cout << endl; |
| |
| cout << "Disable target feature: " << endl; |
| for(int i=0;FeatureEnabledList[i]!=NULL;i++) |
| if(*FeatureEnabledList[i] == '-') |
| cout << "\t" << &FeatureEnabledList[i][1] << endl; |
| cout << endl; |
| |
| cout << "Output to: " << ((strcmp(OutputPathName, "-")) ? OutputPathName : "(standard output)") << ", type: "; |
| switch(OutputFileType) { |
| case SlangCompilerOutput_Assembly: cout << "Target Assembly"; break; |
| case SlangCompilerOutput_LL: cout << "LLVM Assembly"; break; |
| case SlangCompilerOutput_Bitcode: cout << "Bitcode"; break; |
| case SlangCompilerOutput_Nothing: cout << "No output (test)"; break; |
| case SlangCompilerOutput_Obj: cout << "Object file"; break; |
| default: assert(false && "Unknown output type"); break; |
| } |
| cout << endl; |
| } |
| |
| return true; |
| } |
| |
| static void DestroyCommandOptions() { |
| if(SlangOpts != NULL) { |
| delete [] SlangOpts; |
| SlangOpts = NULL; |
| } |
| return; |
| } |
| |
| /* |
| * E.g., replace out/host/linux-x86/bin/slang to out/host/linux-x86/bin/<fileName> |
| */ |
| static std::string replaceLastPartWithFile(std::string& cmd, const char* fileName) { |
| size_t pos = cmd.rfind('/'); |
| if (pos == std::string::npos) { |
| return std::string(fileName); |
| } |
| |
| cmd.resize(pos+1); |
| cmd.append(fileName); |
| return cmd; |
| // std::string returnFile = cmd.substr(0, pos+1).append(fileName); // cmd.replace(pos+1, std::string::npos, fileName); |
| } |
| |
| #define LINK_FILE "/frameworks/compile/slang/rsScriptC_Lib.bc" |
| |
| static char* linkFile() { |
| char* dir = getenv("ANDROID_BUILD_TOP"); |
| char* dirPath; |
| bool readyToLink = false; |
| if (dir) { |
| dirPath = new char[strlen(dir) + strlen(LINK_FILE) + 1]; |
| strcpy(dirPath, dir); |
| strcpy(dirPath + strlen(dir), LINK_FILE); |
| if (open(dirPath, O_RDONLY) >= 0) { |
| readyToLink = true; |
| } |
| } |
| |
| if (!readyToLink) { |
| /* try cwd */ |
| int siz = 256; |
| dir = new char[siz]; |
| while (!getcwd(dir, siz)) { |
| siz *= 2; |
| dir = new char[siz]; |
| } |
| dirPath = new char[strlen(dir) + strlen(LINK_FILE) + 1]; |
| strcpy(dirPath, dir); |
| strcpy(dirPath + strlen(dir), LINK_FILE); |
| //dirPath[strlen(dir) + LINK_FILE_LENGTH] = '\0'; |
| if (open(dirPath, O_RDONLY) < 0) { |
| cerr << "Error: Couldn't load rs library bitcode file" << endl; |
| exit(1); |
| } |
| } |
| return dirPath; |
| } |
| |
| #define LINK_FILE1 "/frameworks/compile/slang/rslib.bc" |
| #define LINK_FILE1_LENGTH 30 |
| |
| static char* linkFile1() { |
| char* dir = getenv("ANDROID_BUILD_TOP"); |
| char* dirPath; |
| bool readyToLink = false; |
| if (dir) { |
| dirPath = new char[strlen(dir) + LINK_FILE1_LENGTH]; |
| strcpy(dirPath, dir); |
| strcpy(dirPath + strlen(dir), LINK_FILE1); |
| if (open(dirPath, O_RDONLY) >= 0) { |
| readyToLink = true; |
| } |
| } |
| |
| if (!readyToLink) { |
| /* try cwd */ |
| int siz = 256; |
| dir = new char[siz]; |
| while (!getcwd(dir, siz)) { |
| siz *= 2; |
| dir = new char[siz]; |
| } |
| dirPath = new char[strlen(dir) + LINK_FILE1_LENGTH]; |
| strcpy(dirPath, dir); |
| strcpy(dirPath + strlen(dir), LINK_FILE1); |
| if (open(dirPath, O_RDONLY) < 0) { |
| cerr << "Error: Couldn't load rs library bitcode file" << endl; |
| exit(1); |
| } |
| } |
| return dirPath; |
| } |
| |
| static int waitForChild(pid_t pid) { |
| pid_t w; |
| int childExitStatus; |
| |
| do { |
| w = waitpid(pid, &childExitStatus, WUNTRACED | WCONTINUED); |
| if (w == -1) { |
| exit(1); |
| } |
| if (WIFEXITED(childExitStatus)) { |
| if (WEXITSTATUS(childExitStatus)) { |
| cerr << "Linking error" << endl; |
| exit(1); |
| } |
| return 0; |
| } else if (WIFSIGNALED(childExitStatus)) { |
| cerr << "Linking: Killed by signal " << WTERMSIG(childExitStatus) << endl; |
| exit(1); |
| } else if (WIFSTOPPED(childExitStatus)) { |
| cerr << "Linking: Stopped by signal " << WSTOPSIG(childExitStatus) << endl; |
| } else if (WIFCONTINUED(childExitStatus)) { |
| cerr << "LInking: Continued" << endl; |
| } |
| } while (!WIFEXITED(childExitStatus) && !WIFSIGNALED(childExitStatus)); |
| return 0; |
| } |
| |
| #define SLANG_CALL_AND_CHECK(expr) \ |
| if(!(expr)) { \ |
| if(slangGetInfoLog(slang)) \ |
| cerr << slangGetInfoLog(slang); \ |
| ret = 1; \ |
| goto on_slang_error; \ |
| } |
| |
| int main(int argc, char** argv) { |
| int ret = 0; |
| int count; |
| |
| std::string command(argv[0]); |
| // char* command = new char[strlen(argv[0])+16]; strcpy(command, argv[0]); |
| |
| if(argc < 2) { |
| cerr << argv[0] << ": "ERR_NO_INPUT_FILE << endl; |
| return 1; |
| } |
| |
| ConstructCommandOptions(); |
| |
| if(ParseOption(argc, argv)) { |
| SlangCompiler* slang = slangCreateCompiler(TripleString, CPUString, FeatureEnabledList); |
| if(slang == NULL) { |
| goto on_slang_error; |
| } |
| |
| slangSetOutputType(slang, OutputFileType); |
| |
| for (size_t i = 0; i < IncludePaths.size(); ++i) { |
| slangAddIncludePath(slang, IncludePaths[i].c_str()); |
| } |
| |
| if (AllowRSPrefix) |
| slangAllowRSPrefix(slang); |
| |
| for (count = 0; count < FileCount; count++) { |
| /* Start compilation */ |
| |
| SLANG_CALL_AND_CHECK( slangSetSourceFromFile(slang, InputFileNames[count].c_str()) ); |
| |
| std::string beforeLink; |
| if (NoLink) { |
| SLANG_CALL_AND_CHECK( slangSetOutputToFile(slang, OutputFileNames[count].c_str()) ); |
| } else { |
| std::string stem = slang::RSSlangReflectUtils::BCFileNameFromRSFileName( |
| InputFileNames[count].c_str()); |
| char tmpFileName[256]; |
| snprintf(tmpFileName, sizeof(tmpFileName), "/tmp/%s.bc.XXXXXX", stem.c_str()); |
| int f = mkstemp(tmpFileName); |
| if (f < 0) { |
| cerr << "Error: could not create temporary file " << tmpFileName << endl; |
| return 1; |
| } |
| // we don't need the file descriptor |
| close(f); |
| |
| beforeLink.assign(tmpFileName); |
| SLANG_CALL_AND_CHECK( slangSetOutputToFile(slang, beforeLink.c_str()) ); |
| } |
| |
| SLANG_CALL_AND_CHECK( slangCompile(slang) <= 0 ); |
| |
| /* Output log anyway */ |
| if(slangGetInfoLog(slang)) { |
| cout << slangGetInfoLog(slang); |
| } |
| |
| SLANG_CALL_AND_CHECK( slangReflectToJavaPath(slang, JavaReflectionPathName) ); |
| |
| char realPackageName[0x100]; |
| SLANG_CALL_AND_CHECK( slangReflectToJava(slang, JavaReflectionPackageName, |
| realPackageName, sizeof(realPackageName))); |
| |
| if (NoLink) { |
| goto generate_bitcode_accessor; |
| } |
| |
| // llvm-rs-link |
| pid_t pid; |
| if ((pid = fork()) < 0) { |
| cerr << "Failed before llvm-rs-link" << endl; |
| exit(1); |
| } else if (pid == 0) { |
| std::string cmd(command); |
| cmd = replaceLastPartWithFile(cmd, "llvm-rs-link"); |
| |
| char* link0 = linkFile(); |
| char* link1 = linkFile1(); |
| if (Externalize) { |
| char* cmdline[] = { (char*)cmd.c_str(), "-e", "-o", (char*)OutputFileNames[count].c_str(), (char*)beforeLink.c_str(), (char*)link0, /*link1,*/ NULL }; |
| execvp(cmd.c_str(), cmdline); |
| } else { |
| //cerr << cmd << " -o " << OutputFileNames[count] << " " << beforeLink << " " << link0 << endl; |
| char* cmdline[] = { (char*)cmd.c_str(), "-o", (char*)OutputFileNames[count].c_str(), (char*)beforeLink.c_str(), (char*)link0, /*link1,*/ NULL }; |
| execvp(cmd.c_str(), cmdline); |
| } |
| } |
| |
| waitForChild(pid); |
| |
| /* // opt |
| if ((pid = fork()) < 0) { |
| cerr << "Failed before opt" << endl; |
| exit(1); |
| } else if (pid == 0) { |
| std::string cmd(command); |
| replaceLastPartWithFile(cmd, "opt"); |
| |
| const char* funcNames = slangExportFuncs(slang); |
| std::string internalize("-internalize-public-api-list=init,root"); |
| if (funcNames) { |
| internalize.append(funcNames); |
| } |
| |
| //cerr << cmd << " -std-link-opts " << internalize << " " << afterLink << " -o " << OutputFileNames[count] << endl; |
| execl(cmd.c_str(), cmd.c_str(), "-std-link-opts", internalize.c_str(), afterLink.c_str(), "-o", OutputFileNames[count].c_str(), NULL); |
| } |
| |
| waitForChild(pid); */ |
| |
| generate_bitcode_accessor: |
| if ((OutputFileType == SlangCompilerOutput_Bitcode) |
| && (BitCodeStorage == slang::BCST_JAVA_CODE) |
| && (OutputFileNames[count] != "stdout")) { |
| slang::RSSlangReflectUtils::BitCodeAccessorContext bc_context; |
| bc_context.rsFileName = InputFileNames[count].c_str(); |
| bc_context.bcFileName = OutputFileNames[count].c_str(); |
| bc_context.reflectPath = JavaReflectionPathName ? JavaReflectionPathName : ""; |
| bc_context.packageName = realPackageName; |
| bc_context.bcStorage = BitCodeStorage; |
| if (!slang::RSSlangReflectUtils::GenerateBitCodeAccessor( |
| bc_context)) { |
| ret = 1; |
| } |
| } |
| } |
| on_slang_error: |
| delete slang; |
| } |
| |
| DestroyCommandOptions(); |
| |
| if (ret) exit(1); |
| return ret; |
| } |
| |
| /* |
| * OUTPUT_OPTION is only used inside Usage() |
| */ |
| #define OUTPUT_OPTION(short_name, long_name, desc) \ |
| do { \ |
| if(short_name) \ |
| cout << setw(4) << right << (short_name) << ", "; \ |
| else \ |
| cout << " "; \ |
| cout << setw(17) << left << (long_name); \ |
| cout << " " << (desc) << endl; \ |
| } while(false) |
| |
| static void Usage(const char* CommandName) { |
| cout << "Usage: " << CommandName << " [OPTION]... " << "[INPUT FILE]" << endl; |
| |
| cout << endl; |
| |
| cout << "Basic: " << endl; |
| |
| OUTPUT_OPTION("-h", "--help", "Print this help"); |
| OUTPUT_OPTION("-v", "--verbose", "Be verbose"); |
| OUTPUT_OPTION(NULL, "--allow-rs-prefix", "Allow user-defined function names with the \"rs\" prefix"); |
| OUTPUT_OPTION(NULL, "--no-link", "Do not link the system bitcode libraries"); |
| OUTPUT_OPTION("-o", "--output-obj-path=<PATH>", "Write compilation output at this path ('-' means stdout)"); |
| OUTPUT_OPTION("-j", "--output-java-reflection-class=<PACKAGE NAME>", "Output reflection of exportables in the native domain into Java"); |
| OUTPUT_OPTION("-p", "--output-java-reflection-path=<PATH>", "Write reflection output at this path"); |
| OUTPUT_OPTION("-I", "--include-path=<PATH>", "Add a hearder search path"); |
| OUTPUT_OPTION("-s", "--bitcode-storage=<VALUE>", "Where to store the bc file. 'ar' means apk resource, 'jc' means Java code."); |
| |
| cout << endl; |
| |
| cout << "Output type:" << endl; |
| |
| OUTPUT_OPTION(NULL, "--emit-llvm", "Set output type to LLVM assembly (.ll)"); |
| OUTPUT_OPTION(NULL, "--emit-bc", "Set output type to Bitcode (.bc) (Default)"); |
| OUTPUT_OPTION("-S", "--emit-asm", "Set output type to target assmbly code (.S)"); |
| OUTPUT_OPTION("-c", "--emit-obj", "Set output type to target object file (.o)"); |
| OUTPUT_OPTION(NULL, "--emit-nothing", "Output nothing"); |
| |
| cout << endl; |
| |
| cout << "Code generation option: " << endl; |
| |
| OUTPUT_OPTION("-u", "--cpu=CPU", "generate the assembly / object file for the CPU"); |
| cout << endl; |
| cout << "\tAvailable CPU:" << endl; |
| |
| for (unsigned i = 0; i < NUM_TARGET_CPU; i++) |
| cout << "\t" << setw(13) << right << TargetCPUTable[i].Name << left << ": (" << TargetArchTable[(TargetCPUTable[i].Arch)].Name << ") " << TargetCPUTable[i].Desc << endl; |
| |
| cout << endl; |
| |
| OUTPUT_OPTION("-t", "--triple=TRIPLE", "generate the assembly / object file for the Triple"); |
| cout << "\tDefault triple: " << endl; |
| #define DEF_SUPPORT_TARGET(target, name, default_triple) \ |
| cout << "\t" << setw(5) << right << name << left << ": " << default_triple << endl; |
| #include "target.inc" |
| cout << endl; |
| |
| OUTPUT_OPTION(NULL, "--enable-FEATURE", "enable the FEATURE for the generation of the assembly / object file"); |
| OUTPUT_OPTION(NULL, "--disable-FEATURE", "disable the FEATURE for the generation of the assembly / object file"); |
| cout << endl; |
| cout << "\tAvailable features:" << endl; |
| #define DEF_TARGET_FEATURE(target, id, key, description) \ |
| cout << "\t" << setw(6) << right << key \ |
| << left << ": (" << TargetArchTable[MK_TARGET_ARCH(target)].Name << ") " \ |
| << description << endl; |
| #include "target.inc" |
| |
| cout << endl; |
| |
| return; |
| } |
| |
| #undef OUTPUT_OPTION |