Move inferred_reg_category_map to greenland.
Change-Id: I33e98b3cfe661f69046362d71f9315bd5b439abd
diff --git a/build/Android.common.mk b/build/Android.common.mk
index 4cfbdd3..e2152df 100644
--- a/build/Android.common.mk
+++ b/build/Android.common.mk
@@ -259,14 +259,14 @@
ifeq ($(ART_USE_LLVM_COMPILER),true)
LIBART_COMMON_SRC_FILES += \
- src/compiler_llvm/inferred_reg_category_map.cc \
+ src/greenland/inferred_reg_category_map.cc \
src/compiler_llvm/procedure_linkage_table.cc \
src/compiler_llvm/runtime_support_llvm.cc
endif
ifeq ($(ART_USE_GREENLAND_COMPILER),true)
LIBART_COMMON_SRC_FILES += \
- src/compiler_llvm/inferred_reg_category_map.cc \
+ src/greenland/inferred_reg_category_map.cc \
src/greenland/runtime_entry_points.cc \
src/greenland/runtime/support_alloc.cc \
src/greenland/runtime/support_cast.cc \
diff --git a/build/Android.libart-compiler-greenland.mk b/build/Android.libart-compiler-greenland.mk
index b999eff..9baef696 100644
--- a/build/Android.libart-compiler-greenland.mk
+++ b/build/Android.libart-compiler-greenland.mk
@@ -18,7 +18,7 @@
LIBART_COMPILER_GREENLAND_CFLAGS := -DART_USE_GREENLAND_COMPILER=1
LIBART_COMPILER_GREENLAND_SRC_FILES += \
- src/compiler_llvm/inferred_reg_category_map.cc \
+ src/greenland/inferred_reg_category_map.cc \
src/greenland/dalvik_reg.cc \
src/greenland/dex_lang.cc \
src/greenland/gbc_context.cc \
diff --git a/build/Android.libart-compiler-llvm.mk b/build/Android.libart-compiler-llvm.mk
index 34de2fa..f39b3ea 100644
--- a/build/Android.libart-compiler-llvm.mk
+++ b/build/Android.libart-compiler-llvm.mk
@@ -24,7 +24,6 @@
src/compiler_llvm/compilation_unit.cc \
src/compiler_llvm/compiler_llvm.cc \
src/compiler_llvm/generated/art_module.cc \
- src/compiler_llvm/inferred_reg_category_map.cc \
src/compiler_llvm/ir_builder.cc \
src/compiler_llvm/jni_compiler.cc \
src/compiler_llvm/md_builder.cc \
@@ -33,7 +32,8 @@
src/compiler_llvm/runtime_support_builder_thumb2.cc \
src/compiler_llvm/runtime_support_builder_x86.cc \
src/compiler_llvm/runtime_support_llvm.cc \
- src/compiler_llvm/stub_compiler.cc
+ src/compiler_llvm/stub_compiler.cc \
+ src/greenland/inferred_reg_category_map.cc
ifeq ($(ART_USE_DEXLANG_FRONTEND),true)
LIBART_COMPILER_LLVM_SRC_FILES += \
diff --git a/src/compiler_llvm/method_compiler.cc b/src/compiler_llvm/method_compiler.cc
index ca8888c..a74a6a4 100644
--- a/src/compiler_llvm/method_compiler.cc
+++ b/src/compiler_llvm/method_compiler.cc
@@ -20,7 +20,7 @@
#include "compilation_unit.h"
#include "compiler.h"
#include "dalvik_reg.h"
-#include "inferred_reg_category_map.h"
+#include "greenland/inferred_reg_category_map.h"
#include "ir_builder.h"
#include "logging.h"
#include "oat_compilation_unit.h"
@@ -2042,26 +2042,26 @@
DecodedInstruction dec_insn(insn);
- int8_t src1_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vA);
- int8_t src2_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vB);
+ greenland::RegCategory src1_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vA);
+ greenland::RegCategory src2_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vB);
- DCHECK_NE(kRegUnknown, src1_reg_cat);
- DCHECK_NE(kRegUnknown, src2_reg_cat);
- DCHECK_NE(kRegCat2, src1_reg_cat);
- DCHECK_NE(kRegCat2, src2_reg_cat);
+ DCHECK_NE(greenland::kRegUnknown, src1_reg_cat);
+ DCHECK_NE(greenland::kRegUnknown, src2_reg_cat);
+ DCHECK_NE(greenland::kRegCat2, src1_reg_cat);
+ DCHECK_NE(greenland::kRegCat2, src2_reg_cat);
int32_t branch_offset = dec_insn.vC;
llvm::Value* src1_value;
llvm::Value* src2_value;
- if (src1_reg_cat == kRegZero && src2_reg_cat == kRegZero) {
+ if (src1_reg_cat == greenland::kRegZero && src2_reg_cat == greenland::kRegZero) {
src1_value = irb_.getInt32(0);
src2_value = irb_.getInt32(0);
- } else if (src1_reg_cat != kRegZero && src2_reg_cat != kRegZero) {
+ } else if (src1_reg_cat != greenland::kRegZero && src2_reg_cat != greenland::kRegZero) {
CHECK_EQ(src1_reg_cat, src2_reg_cat);
- if (src1_reg_cat == kRegCat1nr) {
+ if (src1_reg_cat == greenland::kRegCat1nr) {
src1_value = EmitLoadDalvikReg(dec_insn.vA, kInt, kAccurate);
src2_value = EmitLoadDalvikReg(dec_insn.vB, kInt, kAccurate);
} else {
@@ -2069,11 +2069,11 @@
src2_value = EmitLoadDalvikReg(dec_insn.vB, kObject, kAccurate);
}
} else {
- DCHECK(src1_reg_cat == kRegZero ||
- src2_reg_cat == kRegZero);
+ DCHECK(src1_reg_cat == greenland::kRegZero ||
+ src2_reg_cat == greenland::kRegZero);
- if (src1_reg_cat == kRegZero) {
- if (src2_reg_cat == kRegCat1nr) {
+ if (src1_reg_cat == greenland::kRegZero) {
+ if (src2_reg_cat == greenland::kRegCat1nr) {
src1_value = irb_.getJInt(0);
src2_value = EmitLoadDalvikReg(dec_insn.vA, kInt, kAccurate);
} else {
@@ -2081,7 +2081,7 @@
src2_value = EmitLoadDalvikReg(dec_insn.vA, kObject, kAccurate);
}
} else { // src2_reg_cat == kRegZero
- if (src2_reg_cat == kRegCat1nr) {
+ if (src2_reg_cat == greenland::kRegCat1nr) {
src1_value = EmitLoadDalvikReg(dec_insn.vA, kInt, kAccurate);
src2_value = irb_.getJInt(0);
} else {
@@ -2106,20 +2106,20 @@
DecodedInstruction dec_insn(insn);
- int8_t src_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vA);
+ greenland::RegCategory src_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vA);
- DCHECK_NE(kRegUnknown, src_reg_cat);
- DCHECK_NE(kRegCat2, src_reg_cat);
+ DCHECK_NE(greenland::kRegUnknown, src_reg_cat);
+ DCHECK_NE(greenland::kRegCat2, src_reg_cat);
int32_t branch_offset = dec_insn.vB;
llvm::Value* src1_value;
llvm::Value* src2_value;
- if (src_reg_cat == kRegZero) {
+ if (src_reg_cat == greenland::kRegZero) {
src1_value = irb_.getInt32(0);
src2_value = irb_.getInt32(0);
- } else if (src_reg_cat == kRegCat1nr) {
+ } else if (src_reg_cat == greenland::kRegCat1nr) {
src1_value = EmitLoadDalvikReg(dec_insn.vA, kInt, kAccurate);
src2_value = irb_.getInt32(0);
} else {
@@ -2135,26 +2135,26 @@
GetNextBasicBlock(dex_pc));
}
-const InferredRegCategoryMap* MethodCompiler::GetInferredRegCategoryMap() {
+const greenland::InferredRegCategoryMap* MethodCompiler::GetInferredRegCategoryMap() {
Compiler::MethodReference mref(dex_file_, method_idx_);
- const InferredRegCategoryMap* map =
+ const greenland::InferredRegCategoryMap* map =
verifier::MethodVerifier::GetInferredRegCategoryMap(mref);
- CHECK_NE(map, static_cast<InferredRegCategoryMap*>(NULL));
+ CHECK_NE(map, static_cast<greenland::InferredRegCategoryMap*>(NULL));
return map;
}
-RegCategory MethodCompiler::GetInferredRegCategory(uint32_t dex_pc,
- uint16_t reg_idx) {
- const InferredRegCategoryMap* map = GetInferredRegCategoryMap();
+greenland::RegCategory MethodCompiler::GetInferredRegCategory(uint32_t dex_pc,
+ uint16_t reg_idx) {
+ const greenland::InferredRegCategoryMap* map = GetInferredRegCategoryMap();
return map->GetRegCategory(dex_pc, reg_idx);
}
bool MethodCompiler::IsRegCanBeObject(uint16_t reg_idx) {
- const InferredRegCategoryMap* map = GetInferredRegCategoryMap();
+ const greenland::InferredRegCategoryMap* map = GetInferredRegCategoryMap();
return map->IsRegCanBeObject(reg_idx);
}
diff --git a/src/compiler_llvm/method_compiler.h b/src/compiler_llvm/method_compiler.h
index d54be6b..15b8558 100644
--- a/src/compiler_llvm/method_compiler.h
+++ b/src/compiler_llvm/method_compiler.h
@@ -20,6 +20,7 @@
#include "backend_types.h"
#include "dex_file.h"
#include "dex_instruction.h"
+#include "greenland/backend_types.h"
#include "invoke_type.h"
#include "object_utils.h"
#include "runtime_support_func.h"
@@ -39,6 +40,10 @@
class DexCache;
class Field;
class OatCompilationUnit;
+
+ namespace greenland {
+ class InferredRegCategoryMap;
+ }
}
@@ -361,9 +366,9 @@
llvm::Value* array,
llvm::Value* index);
- RegCategory GetInferredRegCategory(uint32_t dex_pc, uint16_t reg);
+ greenland::RegCategory GetInferredRegCategory(uint32_t dex_pc, uint16_t reg);
- const InferredRegCategoryMap* GetInferredRegCategoryMap();
+ const greenland::InferredRegCategoryMap* GetInferredRegCategoryMap();
bool IsRegCanBeObject(uint16_t reg_idx);
diff --git a/src/greenland/backend_types.h b/src/greenland/backend_types.h
index 483d766..dcdd86d 100644
--- a/src/greenland/backend_types.h
+++ b/src/greenland/backend_types.h
@@ -33,6 +33,7 @@
kFloat,
kDouble,
kObject,
+ MAX_JTYPE
};
@@ -111,10 +112,11 @@
case kObject:
return kRegObject;
- }
- LOG(FATAL) << "Unknown java type: " << jty;
- return kRegUnknown;
+ default:
+ LOG(FATAL) << "Unknown java type: " << jty;
+ return kRegUnknown;
+ }
}
diff --git a/src/greenland/dex_lang.cc b/src/greenland/dex_lang.cc
index 0a5bc27..8568130 100644
--- a/src/greenland/dex_lang.cc
+++ b/src/greenland/dex_lang.cc
@@ -18,7 +18,7 @@
#include "intrinsic_helper.h"
-#include "compiler_llvm/inferred_reg_category_map.h"
+#include "greenland/inferred_reg_category_map.h"
#include "object.h" // FIXME: include this in oat_compilation_unit.h
#include "oat_compilation_unit.h"
#include "stl_util.h"
@@ -857,26 +857,26 @@
return ret_val;
}
-compiler_llvm::InferredRegCategoryMap const* DexLang::GetInferredRegCategoryMap() {
+InferredRegCategoryMap const* DexLang::GetInferredRegCategoryMap() {
Compiler::MethodReference mref(dex_file_, method_idx_);
- compiler_llvm::InferredRegCategoryMap const* map =
+ InferredRegCategoryMap const* map =
verifier::MethodVerifier::GetInferredRegCategoryMap(mref);
- CHECK_NE(map, static_cast<compiler_llvm::InferredRegCategoryMap*>(NULL));
+ CHECK_NE(map, static_cast<InferredRegCategoryMap*>(NULL));
return map;
}
-compiler_llvm::RegCategory DexLang::GetInferredRegCategory(unsigned dex_pc,
- unsigned reg_idx) {
- compiler_llvm::InferredRegCategoryMap const* map = GetInferredRegCategoryMap();
+RegCategory DexLang::GetInferredRegCategory(unsigned dex_pc,
+ unsigned reg_idx) {
+ InferredRegCategoryMap const* map = GetInferredRegCategoryMap();
return map->GetRegCategory(dex_pc, reg_idx);
}
bool DexLang::IsRegCanBeObject(unsigned reg_idx) {
- compiler_llvm::InferredRegCategoryMap const* map = GetInferredRegCategoryMap();
+ InferredRegCategoryMap const* map = GetInferredRegCategoryMap();
return map->IsRegCanBeObject(reg_idx);
}
@@ -1702,21 +1702,20 @@
CondBranchKind cond) {
DecodedInstruction dec_insn(insn);
- compiler_llvm::RegCategory src_reg_cat =
- GetInferredRegCategory(dex_pc, dec_insn.vA);
+ RegCategory src_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vA);
- DCHECK_NE(compiler_llvm::kRegUnknown, src_reg_cat);
- DCHECK_NE(compiler_llvm::kRegCat2, src_reg_cat);
+ DCHECK_NE(kRegUnknown, src_reg_cat);
+ DCHECK_NE(kRegCat2, src_reg_cat);
int32_t branch_offset = dec_insn.vB;
llvm::Value* src1_value;
llvm::Value* src2_value;
- if (src_reg_cat == compiler_llvm::kRegZero) {
+ if (src_reg_cat == kRegZero) {
src1_value = irb_.getInt32(0);
src2_value = irb_.getInt32(0);
- } else if (src_reg_cat == compiler_llvm::kRegCat1nr) {
+ } else if (src_reg_cat == kRegCat1nr) {
src1_value = EmitLoadDalvikReg(dec_insn.vA, kInt, kReg);
src2_value = irb_.getInt32(0);
} else {
diff --git a/src/greenland/dex_lang.h b/src/greenland/dex_lang.h
index 059b972..fdc0a0a 100644
--- a/src/greenland/dex_lang.h
+++ b/src/greenland/dex_lang.h
@@ -18,7 +18,6 @@
#define ART_SRC_GREENLAND_DEX_LANG_H_
#include "backend_types.h"
-#include "compiler_llvm/backend_types.h"
#include "dalvik_reg.h"
#include "ir_builder.h"
@@ -42,15 +41,13 @@
namespace art {
class Compiler;
class OatCompilationUnit;
- namespace compiler_llvm {
- class InferredRegCategoryMap;
- }
}
namespace art {
namespace greenland {
class DalvikReg;
+class InferredRegCategoryMap;
class IntrinsicHelper;
class DexLang {
@@ -168,9 +165,9 @@
//----------------------------------------------------------------------------
// RegCategory
//----------------------------------------------------------------------------
- compiler_llvm::RegCategory GetInferredRegCategory(unsigned dex_pc, unsigned reg_idx);
+ RegCategory GetInferredRegCategory(unsigned dex_pc, unsigned reg_idx);
- compiler_llvm::InferredRegCategoryMap const* GetInferredRegCategoryMap();
+ InferredRegCategoryMap const* GetInferredRegCategoryMap();
bool IsRegCanBeObject(unsigned reg_idx);
diff --git a/src/compiler_llvm/inferred_reg_category_map.cc b/src/greenland/inferred_reg_category_map.cc
similarity index 96%
rename from src/compiler_llvm/inferred_reg_category_map.cc
rename to src/greenland/inferred_reg_category_map.cc
index 0875a3f..86c855c 100644
--- a/src/compiler_llvm/inferred_reg_category_map.cc
+++ b/src/greenland/inferred_reg_category_map.cc
@@ -16,14 +16,13 @@
#include "inferred_reg_category_map.h"
-#include "backend_types.h"
#include "stl_util.h"
#include <stdint.h>
#include <vector>
namespace art {
-namespace compiler_llvm {
+namespace greenland {
InferredRegCategoryMap::InferredRegCategoryMap(uint32_t insns_size,
@@ -99,5 +98,5 @@
}
-} // namespace compiler_llvm
+} // namespace greenland
} // namespace art
diff --git a/src/compiler_llvm/inferred_reg_category_map.h b/src/greenland/inferred_reg_category_map.h
similarity index 90%
rename from src/compiler_llvm/inferred_reg_category_map.h
rename to src/greenland/inferred_reg_category_map.h
index 1626d92..b48dcee 100644
--- a/src/compiler_llvm/inferred_reg_category_map.h
+++ b/src/greenland/inferred_reg_category_map.h
@@ -14,8 +14,8 @@
* limitations under the License.
*/
-#ifndef ART_SRC_COMPILER_LLVM_INFERRED_REG_CATEGORY_MAP_H_
-#define ART_SRC_COMPILER_LLVM_INFERRED_REG_CATEGORY_MAP_H_
+#ifndef ART_SRC_GREENLAND_INFERRED_REG_CATEGORY_MAP_H_
+#define ART_SRC_GREENLAND_INFERRED_REG_CATEGORY_MAP_H_
#include "backend_types.h"
@@ -25,7 +25,7 @@
#include "safe_map.h"
namespace art {
-namespace compiler_llvm {
+namespace greenland {
class InferredRegCategoryMap {
@@ -80,7 +80,7 @@
};
-} // namespace compiler_llvm
+} // namespace greenland
} // namespace art
-#endif // ART_SRC_COMPILER_LLVM_INFERRED_REG_CATEGORY_MAP_H_
+#endif // ART_SRC_GREENLAND_INFERRED_REG_CATEGORY_MAP_H_
diff --git a/src/greenland/ir_builder.cc b/src/greenland/ir_builder.cc
index e83996a..12f9dfa 100644
--- a/src/greenland/ir_builder.cc
+++ b/src/greenland/ir_builder.cc
@@ -76,10 +76,11 @@
case kObject:
return GetJObjectTy();
- }
- LOG(FATAL) << "Unknown java type: " << jty;
- return NULL;
+ default:
+ LOG(FATAL) << "Unknown java type: " << jty;
+ return NULL;
+ }
}
llvm::Type* IRBuilder::GetJTypeInRegSpace(JType jty) {
@@ -134,10 +135,11 @@
case kObject:
return GetJObjectTy();
- }
- LOG(FATAL) << "Unknown java type: " << jty;
- return NULL;
+ default:
+ LOG(FATAL) << "Unknown java type: " << jty;
+ return NULL;
+ }
}
} // namespace greenland
diff --git a/src/object.cc b/src/object.cc
index b131517..bac3ec1 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -39,12 +39,6 @@
#include "utils.h"
#include "well_known_classes.h"
-#if defined(ART_USE_LLVM_COMPILER)
-#include "compiler_llvm/inferred_reg_category_map.h"
-#include "compiler_llvm/runtime_support_llvm.h"
-using art::compiler_llvm::InferredRegCategoryMap;
-#endif
-
namespace art {
String* Object::AsString() {
diff --git a/src/verifier/method_verifier.cc b/src/verifier/method_verifier.cc
index 8695d16..8cbf23e 100644
--- a/src/verifier/method_verifier.cc
+++ b/src/verifier/method_verifier.cc
@@ -33,9 +33,8 @@
#include "stringpiece.h"
#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
-#include "compiler_llvm/backend_types.h"
-#include "compiler_llvm/inferred_reg_category_map.h"
-using namespace art::compiler_llvm;
+#include "greenland/backend_types.h"
+#include "greenland/inferred_reg_category_map.h"
#endif
namespace art {
@@ -3313,7 +3312,7 @@
}
#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
-const InferredRegCategoryMap* MethodVerifier::GenerateInferredRegCategoryMap() {
+const greenland::InferredRegCategoryMap* MethodVerifier::GenerateInferredRegCategoryMap() {
uint32_t insns_size = code_item_->insns_size_in_code_units_;
uint16_t regs_size = code_item_->registers_size_;
@@ -3339,15 +3338,15 @@
const RegType &rt = line->GetRegisterType(r);
if (rt.IsZero()) {
- table->SetRegCategory(i, r, kRegZero);
+ table->SetRegCategory(i, r, greenland::kRegZero);
} else if (rt.IsCategory1Types()) {
- table->SetRegCategory(i, r, kRegCat1nr);
+ table->SetRegCategory(i, r, greenland::kRegCat1nr);
} else if (rt.IsCategory2Types()) {
- table->SetRegCategory(i, r, kRegCat2);
+ table->SetRegCategory(i, r, greenland::kRegCat2);
} else if (rt.IsReferenceTypes()) {
- table->SetRegCategory(i, r, kRegObject);
+ table->SetRegCategory(i, r, greenland::kRegObject);
} else {
- table->SetRegCategory(i, r, kRegUnknown);
+ table->SetRegCategory(i, r, greenland::kRegUnknown);
}
}
}
@@ -3372,7 +3371,7 @@
CHECK(GetInferredRegCategoryMap(ref) != NULL);
}
-const InferredRegCategoryMap*
+const greenland::InferredRegCategoryMap*
MethodVerifier::GetInferredRegCategoryMap(Compiler::MethodReference ref) {
MutexLock mu(*inferred_reg_category_maps_lock_);
diff --git a/src/verifier/method_verifier.h b/src/verifier/method_verifier.h
index 385326d..7eaf672 100644
--- a/src/verifier/method_verifier.h
+++ b/src/verifier/method_verifier.h
@@ -40,9 +40,9 @@
struct ReferenceMap2Visitor;
#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
-namespace compiler_llvm {
+namespace greenland {
class InferredRegCategoryMap;
-} // namespace compiler_llvm
+} // namespace greenland
#endif
namespace verifier {
@@ -144,7 +144,7 @@
// The verifier
class MethodVerifier {
#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
- typedef compiler_llvm::InferredRegCategoryMap InferredRegCategoryMap;
+ typedef greenland::InferredRegCategoryMap InferredRegCategoryMap;
#endif
public:
