Add hybrid assembler concept to ARM assembler.

src/IceClFlags.cpp

 //===- subzero/src/IceClFlags.cpp - Command line flags and parsing --------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 205 matching lines @@
     TranslateOnly("translate-only",
                   cl::desc("Translate only the given function"), cl::init(""));
 
 cl::opt<bool> UseSandboxing("sandbox", cl::desc("Use sandboxing"));
 
 cl::opt<std::string> VerboseFocusOn(
     "verbose-focus",
     cl::desc("Override with -verbose=none except for the specified function"),
     cl::init(""));
 
-cl::opt<Ice::FileType> OutFileType(
-    "filetype", cl::desc("Output file type"), cl::init(Ice::FT_Iasm),
-    cl::values(clEnumValN(Ice::FT_Elf, "obj", "Native ELF object ('.o') file"),
-               clEnumValN(Ice::FT_Asm, "asm", "Assembly ('.s') file"),
-               clEnumValN(Ice::FT_Iasm, "iasm",
+// Allow integrated assembler to use standalone assembler for instructions not
+// yet implemented in the integrated assembler.
+cl::opt<bool>
+    AllowHybridAssembly("hybrid-asm",
+                        cl::desc("Use hybrid of 'asm' and 'iasm' assemblers"),
+                        cl::init(false));
+
+// Extends enum FileType to incorporate a hybrid integrated assembler.
+enum ClFileType {
+  CFT_Elf = Ice::FT_Elf,
+  CFT_Asm = Ice::FT_Asm,
+  CFT_Iasm = Ice::FT_Iasm,
+  CFT_Hasm = 1000 // Intentionally big to not conflict with FT constants.
+};
+
+cl::opt<ClFileType> OutFileType(
+    "filetype", cl::desc("Output file type"), cl::init(CFT_Iasm),
+    cl::values(clEnumValN(CFT_Elf, "obj", "Native ELF object ('.o') file"),
+               clEnumValN(CFT_Asm, "asm", "Assembly ('.s') file"),
+               clEnumValN(CFT_Iasm, "iasm",
                           "Low-level integrated assembly ('.s') file"),
+               clEnumValN(CFT_Hasm, "hasm",
+                          "shortcut for '-filetype=iasm -hybrid-asm'"),
                clEnumValEnd));
 
 cl::opt<int> MaxNopsPerInstruction(
     "max-nops-per-instruction",
     cl::desc("Max number of nops to insert per instruction"), cl::init(1));
 
 cl::opt<int> NopProbabilityAsPercentage(
     "nop-insertion-percentage",
     cl::desc("Nop insertion probability as percentage"), cl::init(10));
 
@@ skipping 127 matching lines @@
 
 void ClFlags::parseFlags(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv);
   AppName = IceString(argv[0]);
 }
 
 void ClFlags::resetClFlags(ClFlags &OutFlags) {
   // bool fields
   OutFlags.AllowErrorRecovery = false;
   OutFlags.AllowExternDefinedSymbols = false;
+  OutFlags.AllowHybridAssembly = false;
   OutFlags.AllowIacaMarks = false;
   OutFlags.AllowUninitializedGlobals = false;
   OutFlags.DataSections = false;
   OutFlags.DecorateAsm = false;
   OutFlags.DisableInternal = false;
   OutFlags.DisableIRGeneration = false;
   OutFlags.DisableTranslation = false;
   OutFlags.DumpStats = false;
   OutFlags.EnableBlockProfile = false;
   OutFlags.ForceMemIntrinOpt = false;
@@ skipping 43 matching lines @@
   // Don't generate verbose messages if routines to dump messages are not
   // available.
   if (BuildDefs::dump()) {
     for (unsigned i = 0; i != VerboseList.size(); ++i)
       VMask |= VerboseList[i];
   }
 
   OutFlags.setAllowErrorRecovery(::AllowErrorRecovery);
   OutFlags.setAllowExternDefinedSymbols(::AllowExternDefinedSymbols ||
                                         ::DisableInternal);
+  OutFlags.setAllowHybridAssembly(::AllowHybridAssembly ||
+                                  ::OutFileType == CFT_Hasm);
   OutFlags.setAllowIacaMarks(::AllowIacaMarks);
   OutFlags.setAllowUninitializedGlobals(::AllowUninitializedGlobals);
   OutFlags.setDataSections(::DataSections);
   OutFlags.setDecorateAsm(::DecorateAsm);
   OutFlags.setDefaultFunctionPrefix(::DefaultFunctionPrefix);
   OutFlags.setDefaultGlobalPrefix(::DefaultGlobalPrefix);
   OutFlags.setDisableInternal(::DisableInternal);
   OutFlags.setDisableIRGeneration(::DisableIRGeneration);
   OutFlags.setDisableTranslation(::DisableTranslation);
   OutFlags.setDumpStats(::DumpStats);
@@ skipping 21 matching lines @@
   OutFlags.setSubzeroTimingEnabled(::SubzeroTimingEnabled);
   OutFlags.setTargetArch(::TargetArch);
   OutFlags.setTargetInstructionSet(::TargetInstructionSet);
   OutFlags.setTestPrefix(::TestPrefix);
   OutFlags.setTestStackExtra(::TestStackExtra);
   OutFlags.setTimeEachFunction(::TimeEachFunction);
   OutFlags.setTimingFocusOn(::TimingFocusOn);
   OutFlags.setTranslateOnly(::TranslateOnly);
   OutFlags.setUseSandboxing(::UseSandboxing);
   OutFlags.setVerboseFocusOn(::VerboseFocusOn);
-  OutFlags.setOutFileType(::OutFileType);
+  OutFlags.setOutFileType(
+      ::OutFileType == CFT_Hasm
+          ? FT_Iasm
+          : static_cast<Ice::FileType>(static_cast<int>(::OutFileType)));
   OutFlags.setMaxNopsPerInstruction(::MaxNopsPerInstruction);
   OutFlags.setNopProbabilityAsPercentage(::NopProbabilityAsPercentage);
   OutFlags.setVerbose(VMask);
 }
 
 void ClFlags::getParsedClFlagsExtra(ClFlagsExtra &OutFlagsExtra) {
   OutFlagsExtra.setAlwaysExitSuccess(AlwaysExitSuccess);
   OutFlagsExtra.setBitcodeAsText(BitcodeAsText);
   OutFlagsExtra.setBuildOnRead(BuildOnRead);
   OutFlagsExtra.setGenerateBuildAtts(GenerateBuildAtts);
   OutFlagsExtra.setLLVMVerboseErrors(LLVMVerboseErrors);
   OutFlagsExtra.setAppName(AppName);
   OutFlagsExtra.setInputFileFormat(InputFileFormat);
   OutFlagsExtra.setIRFilename(IRFilename);
   OutFlagsExtra.setLogFilename(LogFilename);
   OutFlagsExtra.setOutputFilename(OutputFilename);
 }
 
 } // end of namespace Ice