Support for cross compilation.
Refactor architecture specific files into arm and x86 name spaces. Make
assemblers and calling conventions use the factory pattern and an
instruction set specifier.
Change-Id: I20cd7aecacc1ae3d418221d98bbe1d69be9162a7
diff --git a/src/calling_convention_x86.cc b/src/calling_convention_x86.cc
index 92ca780..6cc556a 100644
--- a/src/calling_convention_x86.cc
+++ b/src/calling_convention_x86.cc
@@ -1,48 +1,63 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "calling_convention.h"
+#include "calling_convention_x86.h"
#include "logging.h"
+#include "managed_register_x86.h"
#include "utils.h"
namespace art {
+namespace x86 {
-ManagedRegister CallingConvention::MethodRegister() {
- return ManagedRegister::FromCpuRegister(EDI);
+// Calling convention
+
+ManagedRegister X86ManagedRuntimeCallingConvention::InterproceduralScratchRegister() {
+ return X86ManagedRegister::FromCpuRegister(ECX);
}
-ManagedRegister CallingConvention::InterproceduralScratchRegister() {
- return ManagedRegister::FromCpuRegister(ECX);
+ManagedRegister X86JniCallingConvention::InterproceduralScratchRegister() {
+ return X86ManagedRegister::FromCpuRegister(ECX);
}
-ManagedRegister CallingConvention::ReturnRegister() {
- const Method *method = GetMethod();
+static ManagedRegister ReturnRegisterForMethod(Method* method) {
if (method->IsReturnAFloatOrDouble()) {
- return ManagedRegister::FromX87Register(ST0);
+ return X86ManagedRegister::FromX87Register(ST0);
} else if (method->IsReturnALong()) {
- return ManagedRegister::FromRegisterPair(EAX_EDX);
+ return X86ManagedRegister::FromRegisterPair(EAX_EDX);
} else if (method->IsReturnVoid()) {
return ManagedRegister::NoRegister();
} else {
- return ManagedRegister::FromCpuRegister(EAX);
+ return X86ManagedRegister::FromCpuRegister(EAX);
}
}
+ManagedRegister X86ManagedRuntimeCallingConvention::ReturnRegister() {
+ return ReturnRegisterForMethod(GetMethod());
+}
+
+ManagedRegister X86JniCallingConvention::ReturnRegister() {
+ return ReturnRegisterForMethod(GetMethod());
+}
+
// Managed runtime calling convention
-bool ManagedRuntimeCallingConvention::IsCurrentParamInRegister() {
+ManagedRegister X86ManagedRuntimeCallingConvention::MethodRegister() {
+ return X86ManagedRegister::FromCpuRegister(EDI);
+}
+
+bool X86ManagedRuntimeCallingConvention::IsCurrentParamInRegister() {
return false; // Everything is passed by stack
}
-bool ManagedRuntimeCallingConvention::IsCurrentParamOnStack() {
+bool X86ManagedRuntimeCallingConvention::IsCurrentParamOnStack() {
return true; // Everything is passed by stack
}
-ManagedRegister ManagedRuntimeCallingConvention::CurrentParamRegister() {
+ManagedRegister X86ManagedRuntimeCallingConvention::CurrentParamRegister() {
LOG(FATAL) << "Should not reach here";
return ManagedRegister::NoRegister();
}
-FrameOffset ManagedRuntimeCallingConvention::CurrentParamStackOffset() {
+FrameOffset X86ManagedRuntimeCallingConvention::CurrentParamStackOffset() {
return FrameOffset(displacement_.Int32Value() + // displacement
kPointerSize + // Method*
(itr_slots_ * kPointerSize)); // offset into in args
@@ -50,7 +65,7 @@
// JNI calling convention
-size_t JniCallingConvention::FrameSize() {
+size_t X86JniCallingConvention::FrameSize() {
// Return address and Method*
size_t frame_data_size = 2 * kPointerSize;
// References plus 2 words for SIRT header
@@ -60,49 +75,44 @@
kStackAlignment);
}
-size_t JniCallingConvention::OutArgSize() {
+size_t X86JniCallingConvention::OutArgSize() {
return RoundUp(NumberOfOutgoingStackArgs() * kPointerSize, kStackAlignment);
}
-size_t JniCallingConvention::ReturnPcOffset() {
+size_t X86JniCallingConvention::ReturnPcOffset() {
// Return PC is pushed at the top of the frame by the call into the method
return FrameSize() - kPointerSize;
}
-size_t JniCallingConvention::SpillAreaSize() {
+size_t X86JniCallingConvention::SpillAreaSize() {
// No spills, return address was pushed at the top of the frame
return 0;
}
-void JniCallingConvention::ComputeRegsToSpillPreCall(std::vector<ManagedRegister>& regs) {
- // No live values in registers (everything is on the stack) so never anything
- // to preserve.
-}
-
-bool JniCallingConvention::IsOutArgRegister(ManagedRegister) {
+bool X86JniCallingConvention::IsOutArgRegister(ManagedRegister) {
return false; // Everything is passed by stack
}
-bool JniCallingConvention::IsCurrentParamInRegister() {
+bool X86JniCallingConvention::IsCurrentParamInRegister() {
return false; // Everything is passed by stack
}
-bool JniCallingConvention::IsCurrentParamOnStack() {
+bool X86JniCallingConvention::IsCurrentParamOnStack() {
return true; // Everything is passed by stack
}
-ManagedRegister JniCallingConvention::CurrentParamRegister() {
+ManagedRegister X86JniCallingConvention::CurrentParamRegister() {
LOG(FATAL) << "Should not reach here";
return ManagedRegister::NoRegister();
}
-FrameOffset JniCallingConvention::CurrentParamStackOffset() {
+FrameOffset X86JniCallingConvention::CurrentParamStackOffset() {
return FrameOffset(displacement_.Int32Value() - OutArgSize() +
(itr_slots_ * kPointerSize));
}
-size_t JniCallingConvention::NumberOfOutgoingStackArgs() {
+size_t X86JniCallingConvention::NumberOfOutgoingStackArgs() {
size_t static_args = GetMethod()->IsStatic() ? 1 : 0; // count jclass
// regular argument parameters and this
size_t param_args = GetMethod()->NumArgs() +
@@ -110,4 +120,5 @@
return static_args + param_args + 1; // count JNIEnv*
}
+} // namespace x86
} // namespace art