| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /** |
| * @author Vyacheslav P. Shakin |
| */ |
| |
| #include "Ia32CallingConvention.h" |
| #include "Ia32IRManager.h" |
| |
| namespace Jitrino { |
| namespace Ia32 { |
| |
| const CallingConvention * CallingConvention::str2cc(const char * cc_name) { |
| if( NULL == cc_name ) { // default |
| return &CallingConvention_STDCALL; |
| } |
| |
| if( !strcmpi(cc_name, "stdcall") ) { |
| return &CallingConvention_STDCALL; |
| } |
| |
| if( !strcmpi(cc_name, "drl") ) { |
| return &CallingConvention_Managed; |
| } |
| |
| if( !strcmpi(cc_name, "cdecl") ) { |
| return &CallingConvention_CDECL; |
| } |
| assert( false ); |
| return NULL; |
| } |
| |
| |
| //======================================================================================== |
| STDCALLCallingConvention CallingConvention_STDCALL; |
| CDECLCallingConvention CallingConvention_CDECL; |
| ManagedCallingConvention CallingConvention_Managed; |
| MultiArrayCallingConvention CallingConvention_MultiArray; |
| |
| //======================================================================================== |
| // STDCALLCallingConvention |
| //======================================================================================== |
| |
| #ifdef _EM64T_ |
| #ifdef _WIN64 |
| const RegName fastCallGPRegs[4] = {RegName_RCX, RegName_RDX, RegName_R8, RegName_R9} ; |
| const RegName fastCallFPRegs[4] = {RegName_XMM0,RegName_XMM1,RegName_XMM2,RegName_XMM3}; |
| #else |
| const RegName fastCallGPRegs[6] = {RegName_RDI, RegName_RSI, RegName_RDX, RegName_RCX, RegName_R8, RegName_R9} ; |
| const RegName fastCallFPRegs[8] = {RegName_XMM0,RegName_XMM1,RegName_XMM2,RegName_XMM3,RegName_XMM4,RegName_XMM5,RegName_XMM6,RegName_XMM7}; |
| #endif |
| #endif |
| |
| #ifdef _IA32_ |
| //______________________________________________________________________________________ |
| void STDCALLCallingConventionIA32::getOpndInfo(ArgKind kind, U_32 count, OpndInfo * infos) const |
| { |
| if (kind == ArgKind_InArg) { |
| for (U_32 i=0; i<count; i++){ |
| |
| Type::Tag typeTag=(Type::Tag)infos[i].typeTag; |
| OpndSize size=IRManager::getTypeSize(typeTag); |
| assert(size!=OpndSize_Null && size<=OpndSize_64); |
| |
| infos[i].slotCount=1; |
| infos[i].slots[0]=RegName_Null; |
| infos[i].isReg=false; |
| |
| if (size==OpndSize_64){ |
| infos[i].slotCount=2; |
| infos[i].slots[1]=RegName_Null; |
| } |
| } |
| } else { |
| assert(kind == ArgKind_RetArg); |
| assert(count <= 1); |
| if (count == 1) { |
| Type::Tag typeTag=(Type::Tag)infos[0].typeTag; |
| infos[0].isReg=true; |
| switch (typeTag) { |
| case Type::Void: |
| infos[0].slotCount=0; |
| break; |
| case Type::Float: |
| case Type::Double: |
| case Type::Single: |
| infos[0].slotCount=1; |
| infos[0].slots[0]=RegName_FP0; |
| break; |
| default: { |
| OpndSize size=IRManager::getTypeSize(typeTag); |
| assert(size!=OpndSize_Null && size<=OpndSize_64); |
| |
| infos[0].slotCount=1; |
| infos[0].slots[0]=RegName_EAX; |
| |
| if (size == OpndSize_64) { |
| infos[0].slotCount=2; |
| infos[0].slots[1]=RegName_EDX; |
| } |
| } |
| }; |
| } |
| } |
| } |
| |
| #else |
| void STDCALLCallingConventionEM64T::getOpndInfo(ArgKind kind, U_32 count, OpndInfo * infos) const |
| { |
| if (kind == ArgKind_InArg) { |
| U_32 gpreg = 0; |
| #ifdef _WIN64 |
| #define fpreg gpreg |
| #else |
| U_32 fpreg = 0; |
| #endif |
| |
| for (U_32 i=0; i<count; i++){ |
| |
| Type::Tag typeTag=(Type::Tag)infos[i].typeTag; |
| if(((typeTag>Type::Float ||typeTag<Type::Single) && gpreg < lengthof(fastCallGPRegs))) { |
| infos[i].slotCount=1; |
| infos[i].slots[0]=fastCallGPRegs[gpreg]; |
| infos[i].isReg=true; |
| gpreg++; |
| } else if(((typeTag<=Type::Float && typeTag>=Type::Single) && fpreg < lengthof(fastCallFPRegs))) { |
| infos[i].slotCount=1; |
| infos[i].slots[0]=fastCallFPRegs[fpreg]; |
| infos[i].isReg=true; |
| fpreg++; |
| } else { |
| infos[i].slotCount=1; |
| infos[i].slots[0]=RegName_Null; |
| infos[i].isReg=false; |
| } |
| } |
| } else { |
| assert(kind == ArgKind_RetArg); |
| assert(count <= 1); |
| if (count == 1) { |
| Type::Tag typeTag=(Type::Tag)infos[0].typeTag; |
| infos[0].isReg=true; |
| switch (typeTag) { |
| case Type::Void: |
| infos[0].slotCount=0; |
| break; |
| case Type::Float: |
| case Type::Double: |
| case Type::Single: |
| infos[0].slotCount=1; |
| infos[0].slots[0]=RegName_XMM0; |
| break; |
| default: { |
| OpndSize size=IRManager::getTypeSize(typeTag); |
| infos[0].slotCount=1; |
| infos[0].slots[0]=RegName_RAX; |
| |
| if (size == OpndSize_128) { |
| infos[0].slotCount=2; |
| infos[0].slots[1]=RegName_RDX; |
| } |
| } |
| }; |
| } |
| } |
| } |
| #endif |
| |
| #ifdef _IA32_ |
| //______________________________________________________________________________________ |
| Constraint STDCALLCallingConventionIA32::getCalleeSavedRegs(OpndKind regKind) const |
| { |
| switch (regKind){ |
| case OpndKind_GPReg: |
| return (Constraint(RegName_EBX)|RegName_EBP|RegName_ESI|RegName_EDI); |
| default: |
| return Constraint(); |
| } |
| } |
| |
| #else |
| Constraint STDCALLCallingConventionEM64T::getCalleeSavedRegs(OpndKind regKind) const |
| { |
| switch (regKind){ |
| case OpndKind_GPReg: |
| #ifdef _WIN64 |
| return (Constraint(RegName_RBX)|RegName_RBP|RegName_R12|RegName_R13|RegName_R14|RegName_R15|RegName_RSI|RegName_RDI); |
| #else |
| return (Constraint(RegName_RBX)|RegName_RBP|RegName_R12|RegName_R13|RegName_R14|RegName_R15); |
| #endif |
| default: |
| return Constraint(); |
| } |
| } |
| #endif |
| |
| |
| //______________________________________________________________________________________ |
| #ifdef _IA32_ |
| void ManagedCallingConventionIA32::getOpndInfo(ArgKind kind, U_32 count, OpndInfo * infos) const |
| { |
| if (kind == ArgKind_RetArg) { |
| assert(count <= 1); |
| if (count == 1) { |
| Type::Tag typeTag = (Type::Tag)infos[0].typeTag; |
| switch (typeTag) { |
| case Type::Float: |
| case Type::Double: |
| case Type::Single: |
| infos[0].isReg = true; |
| infos[0].slotCount = 1; |
| infos[0].slots[0] = RegName_XMM0; |
| return; |
| default:; |
| }; |
| } |
| |
| } |
| return STDCALLCallingConventionIA32::getOpndInfo(kind, count, infos); |
| } |
| #else |
| #endif |
| |
| #ifdef _IA32_ |
| #else |
| void MultiArrayCallingConventionEM64T::getOpndInfo(ArgKind kind, U_32 count, OpndInfo * infos) const |
| { |
| if (kind == ArgKind_InArg){ |
| for (U_32 i = 0; i < count; i++) { |
| infos[i].slotCount = 1; |
| infos[i].slots[0] = RegName_Null; |
| infos[i].isReg = false; |
| } |
| } else { |
| CDECLCallingConventionEM64T::getOpndInfo(kind, count, infos); |
| } |
| } |
| #endif |
| |
| }; // namespace Ia32 |
| } |
