Rename compiler_llvm CompilationUnit to LlvmCompilationUnit

Also fixed stray ART_TEST_CFLAGS to LOCAL_CFLAGS
Also fixed relative includes

Tried to change CompilationUnit to reference LlvmCompilationUnit, but
that causes issues because of the split libart-compiler
libart-compiler-llvm.

Change-Id: I7a490f339add6355a20c1cedae858ccf6967a6aa

10 files changed, 44 insertions, 42 deletions

diff --git a/src/compiler_llvm/compiler_llvm.cc b/src/compiler_llvm/compiler_llvm.cc
index 97d005c67f..72379116a2 100644
--- a/src/compiler_llvm/compiler_llvm.cc
+++ b/src/compiler_llvm/compiler_llvm.cc
@@ -19,11 +19,11 @@
 #include "base/stl_util.h"
 #include "backend_options.h"
 #include "class_linker.h"
-#include "compilation_unit.h"
 #include "compiled_method.h"
 #include "compiler.h"
 #include "ir_builder.h"
 #include "jni_compiler.h"
+#include "llvm_compilation_unit.h"
 #include "method_compiler.h"
 #include "oat_compilation_unit.h"
 #include "oat_file.h"
@@ -125,11 +125,11 @@ CompilerLLVM::~CompilerLLVM() {
 }
 
 
-CompilationUnit* CompilerLLVM::AllocateCompilationUnit() {
+LlvmCompilationUnit* CompilerLLVM::AllocateCompilationUnit() {
   MutexLock GUARD(Thread::Current(), num_cunits_lock_);
-  CompilationUnit* cunit = new CompilationUnit(this, num_cunits_++);
+  LlvmCompilationUnit* cunit = new LlvmCompilationUnit(this, num_cunits_++);
   if (!bitcode_filename_.empty()) {
-    cunit->SetBitcodeFileName(StringPrintf("%s-%zu", bitcode_filename_.c_str(), num_cunits_-1));
+    cunit->SetBitcodeFileName(StringPrintf("%s-%zu", bitcode_filename_.c_str(), cunit->GetIndex()));
   }
   return cunit;
 }
@@ -137,7 +137,7 @@ CompilationUnit* CompilerLLVM::AllocateCompilationUnit() {
 
 CompiledMethod* CompilerLLVM::
 CompileDexMethod(OatCompilationUnit* oat_compilation_unit, InvokeType invoke_type) {
-  UniquePtr<CompilationUnit> cunit(AllocateCompilationUnit());
+  UniquePtr<LlvmCompilationUnit> cunit(AllocateCompilationUnit());
 
 #if defined(ART_USE_PORTABLE_COMPILER)
   std::string methodName(PrettyMethod(oat_compilation_unit->GetDexMethodIndex(),
@@ -185,7 +185,7 @@ CompileDexMethod(OatCompilationUnit* oat_compilation_unit, InvokeType invoke_typ
 
 CompiledMethod* CompilerLLVM::
 CompileNativeMethod(OatCompilationUnit* oat_compilation_unit) {
-  UniquePtr<CompilationUnit> cunit(AllocateCompilationUnit());
+  UniquePtr<LlvmCompilationUnit> cunit(AllocateCompilationUnit());
 
   UniquePtr<JniCompiler> jni_compiler(
       new JniCompiler(cunit.get(), *compiler_, oat_compilation_unit));
@@ -196,7 +196,7 @@ CompileNativeMethod(OatCompilationUnit* oat_compilation_unit) {
 
 CompiledInvokeStub* CompilerLLVM::CreateInvokeStub(bool is_static,
                                                    char const *shorty) {
-  UniquePtr<CompilationUnit> cunit(AllocateCompilationUnit());
+  UniquePtr<LlvmCompilationUnit> cunit(AllocateCompilationUnit());
 
   UniquePtr<StubCompiler> stub_compiler(
     new StubCompiler(cunit.get(), *compiler_));
@@ -206,7 +206,7 @@ CompiledInvokeStub* CompilerLLVM::CreateInvokeStub(bool is_static,
 
 
 CompiledInvokeStub* CompilerLLVM::CreateProxyStub(char const *shorty) {
-  UniquePtr<CompilationUnit> cunit(AllocateCompilationUnit());
+  UniquePtr<LlvmCompilationUnit> cunit(AllocateCompilationUnit());
 
   UniquePtr<StubCompiler> stub_compiler(
     new StubCompiler(cunit.get(), *compiler_));
diff --git a/src/compiler_llvm/compiler_llvm.h b/src/compiler_llvm/compiler_llvm.h
index bb14c49163..b11ce121f4 100644
--- a/src/compiler_llvm/compiler_llvm.h
+++ b/src/compiler_llvm/compiler_llvm.h
@@ -55,7 +55,7 @@ namespace llvm {
 namespace art {
 namespace compiler_llvm {
 
-class CompilationUnit;
+class LlvmCompilationUnit;
 class IRBuilder;
 
 class CompilerLLVM {
@@ -94,7 +94,7 @@ class CompilerLLVM {
   }
 
  private:
-  CompilationUnit* AllocateCompilationUnit();
+  LlvmCompilationUnit* AllocateCompilationUnit();
 
   Compiler* compiler_;
 
diff --git a/src/compiler_llvm/jni_compiler.cc b/src/compiler_llvm/jni_compiler.cc
index fdd2b43358..8d49aba971 100644
--- a/src/compiler_llvm/jni_compiler.cc
+++ b/src/compiler_llvm/jni_compiler.cc
@@ -18,11 +18,11 @@
 
 #include "base/logging.h"
 #include "class_linker.h"
-#include "compilation_unit.h"
 #include "compiled_method.h"
 #include "compiler.h"
 #include "compiler_llvm.h"
 #include "ir_builder.h"
+#include "llvm_compilation_unit.h"
 #include "mirror/abstract_method.h"
 #include "oat_compilation_unit.h"
 #include "runtime.h"
@@ -42,7 +42,7 @@ namespace compiler_llvm {
 
 using namespace runtime_support;
 
-JniCompiler::JniCompiler(CompilationUnit* cunit,
+JniCompiler::JniCompiler(LlvmCompilationUnit* cunit,
                          Compiler const& compiler,
                          OatCompilationUnit* oat_compilation_unit)
 : cunit_(cunit), compiler_(&compiler), module_(cunit_->GetModule()),
diff --git a/src/compiler_llvm/jni_compiler.h b/src/compiler_llvm/jni_compiler.h
index 0731e92a52..46481802b5 100644
--- a/src/compiler_llvm/jni_compiler.h
+++ b/src/compiler_llvm/jni_compiler.h
@@ -46,12 +46,12 @@ namespace llvm {
 namespace art {
 namespace compiler_llvm {
 
-class CompilationUnit;
+class LlvmCompilationUnit;
 class IRBuilder;
 
 class JniCompiler {
  public:
-  JniCompiler(CompilationUnit* cunit,
+  JniCompiler(LlvmCompilationUnit* cunit,
               Compiler const& compiler,
               OatCompilationUnit* oat_compilation_unit);
 
@@ -64,7 +64,7 @@ class JniCompiler {
                                       bool is_static, bool is_target_function);
 
  private:
-  CompilationUnit* cunit_;
+  LlvmCompilationUnit* cunit_;
   const Compiler* compiler_;
 
   llvm::Module* module_;
diff --git a/src/compiler_llvm/compilation_unit.cc b/src/compiler_llvm/llvm_compilation_unit.cc
index bd2d8fc8ba..97aa6b911a 100644
--- a/src/compiler_llvm/compilation_unit.cc
+++ b/src/compiler_llvm/llvm_compilation_unit.cc
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "compilation_unit.h"
+#include "llvm_compilation_unit.h"
 
 #include "base/logging.h"
 #include "compiled_method.h"
@@ -89,7 +89,7 @@ CreateGBCExpanderPass(const greenland::IntrinsicHelper& intrinsic_helper, IRBuil
 llvm::Module* makeLLVMModuleContents(llvm::Module* module);
 
 
-CompilationUnit::CompilationUnit(const CompilerLLVM* compiler_llvm,
+LlvmCompilationUnit::LlvmCompilationUnit(const CompilerLLVM* compiler_llvm,
                                  size_t cunit_idx)
 : compiler_llvm_(compiler_llvm), cunit_idx_(cunit_idx) {
 #if !defined(ART_USE_PORTABLE_COMPILER)
@@ -129,7 +129,7 @@ CompilationUnit::CompilationUnit(const CompilerLLVM* compiler_llvm,
 }
 
 
-CompilationUnit::~CompilationUnit() {
+LlvmCompilationUnit::~LlvmCompilationUnit() {
 #if defined(ART_USE_PORTABLE_COMPILER)
   llvm::LLVMContext* llvm_context = context_.release(); // Managed by llvm_info_
   CHECK(llvm_context != NULL);
@@ -137,12 +137,12 @@ CompilationUnit::~CompilationUnit() {
 }
 
 
-InstructionSet CompilationUnit::GetInstructionSet() const {
+InstructionSet LlvmCompilationUnit::GetInstructionSet() const {
   return compiler_llvm_->GetInstructionSet();
 }
 
 
-bool CompilationUnit::Materialize() {
+bool LlvmCompilationUnit::Materialize() {
   std::string elf_image;
 
   // Compile and prelink llvm::Module
@@ -170,13 +170,13 @@ bool CompilationUnit::Materialize() {
 }
 
 
-bool CompilationUnit::MaterializeToString(std::string& str_buffer) {
+bool LlvmCompilationUnit::MaterializeToString(std::string& str_buffer) {
   llvm::raw_string_ostream str_os(str_buffer);
   return MaterializeToRawOStream(str_os);
 }
 
 
-bool CompilationUnit::MaterializeToRawOStream(llvm::raw_ostream& out_stream) {
+bool LlvmCompilationUnit::MaterializeToRawOStream(llvm::raw_ostream& out_stream) {
   // Lookup the LLVM target
   std::string target_triple;
   std::string target_cpu;
@@ -295,7 +295,7 @@ bool CompilationUnit::MaterializeToRawOStream(llvm::raw_ostream& out_stream) {
   return true;
 }
 
-bool CompilationUnit::ExtractCodeAndPrelink(const std::string& elf_image) {
+bool LlvmCompilationUnit::ExtractCodeAndPrelink(const std::string& elf_image) {
   if (GetInstructionSet() == kX86) {
     compiled_code_.push_back(0xccU);
     compiled_code_.push_back(0xccU);
@@ -405,7 +405,7 @@ bool CompilationUnit::ExtractCodeAndPrelink(const std::string& elf_image) {
 // that architecture.  Since the Oat writer only guarantee that the compiled
 // method being aligned to kArchAlignment, we have no way to align the ELf
 // section if the section alignment is greater than kArchAlignment.
-void CompilationUnit::CheckCodeAlign(uint32_t align) const {
+void LlvmCompilationUnit::CheckCodeAlign(uint32_t align) const {
   InstructionSet insn_set = GetInstructionSet();
   switch (insn_set) {
   case kThumb2:
diff --git a/src/compiler_llvm/compilation_unit.h b/src/compiler_llvm/llvm_compilation_unit.h
index b0d072b166..af3ba7a7e0 100644
--- a/src/compiler_llvm/compilation_unit.h
+++ b/src/compiler_llvm/llvm_compilation_unit.h
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ART_SRC_COMPILER_LLVM_COMPILATION_UNIT_H_
-#define ART_SRC_COMPILER_LLVM_COMPILATION_UNIT_H_
+#ifndef ART_SRC_COMPILER_LLVM_LLVM_COMPILATION_UNIT_H_
+#define ART_SRC_COMPILER_LLVM_LLVM_COMPILATION_UNIT_H_
 
 #include "base/logging.h"
 #include "base/mutex.h"
@@ -52,12 +52,9 @@ namespace compiler_llvm {
 class CompilerLLVM;
 class IRBuilder;
 
-class CompilationUnit {
+class LlvmCompilationUnit {
  public:
-  CompilationUnit(const CompilerLLVM* compiler_llvm,
-                  size_t cunit_idx);
-
-  ~CompilationUnit();
+  ~LlvmCompilationUnit();
 
   size_t GetIndex() const {
     return cunit_idx_;
@@ -105,6 +102,9 @@ class CompilationUnit {
   }
 
  private:
+  LlvmCompilationUnit(const CompilerLLVM* compiler_llvm,
+                      size_t cunit_idx);
+
   const CompilerLLVM* compiler_llvm_;
   const size_t cunit_idx_;
 
@@ -130,9 +130,11 @@ class CompilationUnit {
   bool MaterializeToRawOStream(llvm::raw_ostream& out_stream);
 
   bool ExtractCodeAndPrelink(const std::string& elf_image);
+
+  friend class CompilerLLVM;  // For LlvmCompilationUnit constructor
 };
 
 } // namespace compiler_llvm
 } // namespace art
 
-#endif // ART_SRC_COMPILER_LLVM_COMPILATION_UNIT_H_
+#endif // ART_SRC_COMPILER_LLVM_LLVM_COMPILATION_UNIT_H_
diff --git a/src/compiler_llvm/method_compiler.cc b/src/compiler_llvm/method_compiler.cc
index 76b1299b6f..47d9b015ff 100644
--- a/src/compiler_llvm/method_compiler.cc
+++ b/src/compiler_llvm/method_compiler.cc
@@ -20,11 +20,11 @@
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
-#include "compilation_unit.h"
 #include "compiler.h"
 #include "dalvik_reg.h"
 #include "greenland/inferred_reg_category_map.h"
 #include "ir_builder.h"
+#include "llvm_compilation_unit.h"
 #include "mirror/object.h"
 #include "oat_compilation_unit.h"
 #include "object_utils.h"
@@ -46,7 +46,7 @@ namespace compiler_llvm {
 using namespace runtime_support;
 
 
-MethodCompiler::MethodCompiler(CompilationUnit* cunit,
+MethodCompiler::MethodCompiler(LlvmCompilationUnit* cunit,
                                Compiler* compiler,
                                OatCompilationUnit* oat_compilation_unit)
   : cunit_(cunit), compiler_(compiler),
diff --git a/src/compiler_llvm/method_compiler.h b/src/compiler_llvm/method_compiler.h
index dd9d1829c3..4d759e501a 100644
--- a/src/compiler_llvm/method_compiler.h
+++ b/src/compiler_llvm/method_compiler.h
@@ -64,14 +64,14 @@ namespace llvm {
 namespace art {
 namespace compiler_llvm {
 
-class CompilationUnit;
+class LlvmCompilationUnit;
 class CompilerLLVM;
 class DalvikReg;
 class IRBuilder;
 
 class MethodCompiler {
  public:
-  MethodCompiler(CompilationUnit* cunit,
+  MethodCompiler(LlvmCompilationUnit* cunit,
                  Compiler* compiler,
                  OatCompilationUnit* oat_compilation_unit);
 
@@ -447,7 +447,7 @@ class MethodCompiler {
   void ComputeMethodInfo();
 
  private:
-  CompilationUnit* cunit_;
+  LlvmCompilationUnit* cunit_;
   Compiler* compiler_;
 
   const DexFile* dex_file_;
diff --git a/src/compiler_llvm/stub_compiler.cc b/src/compiler_llvm/stub_compiler.cc
index 6b2a479426..e6bee7b620 100644
--- a/src/compiler_llvm/stub_compiler.cc
+++ b/src/compiler_llvm/stub_compiler.cc
@@ -17,11 +17,11 @@
 #include "stub_compiler.h"
 
 #include "base/logging.h"
-#include "compilation_unit.h"
 #include "compiled_method.h"
 #include "compiler.h"
 #include "compiler_llvm.h"
 #include "ir_builder.h"
+#include "llvm_compilation_unit.h"
 #include "mirror/abstract_method.h"
 #include "runtime_support_func.h"
 #include "utils_llvm.h"
@@ -40,7 +40,7 @@ namespace compiler_llvm {
 using namespace runtime_support;
 
 
-StubCompiler::StubCompiler(CompilationUnit* cunit, Compiler& compiler)
+StubCompiler::StubCompiler(LlvmCompilationUnit* cunit, Compiler& compiler)
 : cunit_(cunit), compiler_(&compiler), module_(cunit_->GetModule()),
   context_(cunit_->GetLLVMContext()), irb_(*cunit_->GetIRBuilder()) {
 }
diff --git a/src/compiler_llvm/stub_compiler.h b/src/compiler_llvm/stub_compiler.h
index 9139accd68..312b3af275 100644
--- a/src/compiler_llvm/stub_compiler.h
+++ b/src/compiler_llvm/stub_compiler.h
@@ -33,19 +33,19 @@ namespace llvm {
 namespace art {
 namespace compiler_llvm {
 
-class CompilationUnit;
+class LlvmCompilationUnit;
 class CompilerLLVM;
 class IRBuilder;
 
 class StubCompiler {
  public:
-  StubCompiler(CompilationUnit* cunit, Compiler& compiler);
+  StubCompiler(LlvmCompilationUnit* cunit, Compiler& compiler);
 
   CompiledInvokeStub* CreateInvokeStub(bool is_static, const char* shorty);
   CompiledInvokeStub* CreateProxyStub(const char* shorty);
 
  private:
-  CompilationUnit* cunit_;
+  LlvmCompilationUnit* cunit_;
   const Compiler* compiler_;
   llvm::Module* module_;
   llvm::LLVMContext* context_;