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