// Licensed to the .NET Foundation under one or more agreements.

// The .NET Foundation licenses this file to you under the MIT license.

// See the LICENSE file in the project root for more information.

/*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

XX XX

XX Compiler XX

XX XX

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

*/

#include "jitpch.h"

#ifdef _MSC_VER

#pragma hdrstop

#endif // _MSC_VER

#include "hostallocator.h"

#include "emit.h"

#include "ssabuilder.h"

#include "valuenum.h"

#include "rangecheck.h"

#include "lower.h"

#include "stacklevelsetter.h"

#include "jittelemetry.h"

#if defined(DEBUG)

// Column settings for COMPlus_JitDumpIR. We could(should) make these programmable.

#define COLUMN_OPCODE 30

#define COLUMN_OPERANDS (COLUMN_OPCODE + 25)

#define COLUMN_KINDS 110

#define COLUMN_FLAGS (COLUMN_KINDS + 32)

#endif

#if defined(DEBUG)

unsigned Compiler::jitTotalMethodCompiled = 0;

#endif // defined(DEBUG)

#if defined(DEBUG)

LONG Compiler::jitNestingLevel = 0;

#endif // defined(DEBUG)

#ifdef ALT_JIT

// static

bool Compiler::s_pAltJitExcludeAssembliesListInitialized = false;

AssemblyNamesList2* Compiler::s_pAltJitExcludeAssembliesList = nullptr;

#endif // ALT_JIT

#ifdef DEBUG

// static

bool Compiler::s_pJitDisasmIncludeAssembliesListInitialized = false;

AssemblyNamesList2* Compiler::s_pJitDisasmIncludeAssembliesList = nullptr;

// static

bool Compiler::s_pJitFunctionFileInitialized = false;

MethodSet* Compiler::s_pJitMethodSet = nullptr;

#endif // DEBUG

/*****************************************************************************

*

* Little helpers to grab the current cycle counter value; this is done

* differently based on target architecture, host toolchain, etc. The

* main thing is to keep the overhead absolutely minimal; in fact, on

* x86/x64 we use RDTSC even though it's not thread-safe; GetThreadCycles

* (which is monotonous) is just too expensive.

*/

#ifdef FEATURE_JIT_METHOD_PERF

#if defined(_HOST_X86_) || defined(_HOST_AMD64_)

#if defined(_MSC_VER)

#include <intrin.h>

inline bool _our_GetThreadCycles(unsigned __int64* cycleOut)

{

*cycleOut = __rdtsc();

return true;

}

#elif defined(__GNUC__)

inline bool _our_GetThreadCycles(unsigned __int64* cycleOut)

{

uint32_t hi, lo;

__asm__ __volatile__("rdtsc" : "=a"(lo), "=d"(hi));

*cycleOut = (static_cast<unsigned __int64>(hi) << 32) | static_cast<unsigned __int64>(lo);

return true;

}

#else // neither _MSC_VER nor __GNUC__

// The following *might* work - might as well try.

#define _our_GetThreadCycles(cp) GetThreadCycles(cp)

#endif

#elif defined(_HOST_ARM_) || defined(_HOST_ARM64_)

// If this doesn't work please see ../gc/gc.cpp for additional ARM

// info (and possible solutions).

#define _our_GetThreadCycles(cp) GetThreadCycles(cp)

#else // not x86/x64 and not ARM

// Don't know what this target is, but let's give it a try; if

// someone really wants to make this work, please add the right

// code here.

#define _our_GetThreadCycles(cp) GetThreadCycles(cp)

#endif // which host OS

#endif // FEATURE_JIT_METHOD_PERF

/*****************************************************************************/

inline unsigned getCurTime()

{

SYSTEMTIME tim;

GetSystemTime(&tim);

return (((tim.wHour * 60) + tim.wMinute) * 60 + tim.wSecond) * 1000 + tim.wMilliseconds;

}

/*****************************************************************************/

#ifdef DEBUG

/*****************************************************************************/

static FILE* jitSrcFilePtr;

static unsigned jitCurSrcLine;

void Compiler::JitLogEE(unsigned level, const char* fmt, ...)

{

va_list args;

if (verbose)

{

va_start(args, fmt);

vflogf(jitstdout, fmt, args);

va_end(args);

}

va_start(args, fmt);

vlogf(level, fmt, args);

va_end(args);

}

void Compiler::compDspSrcLinesByLineNum(unsigned line, bool seek)

{

if (!jitSrcFilePtr)

{

return;

}

if (jitCurSrcLine == line)

{

return;

}

if (jitCurSrcLine > line)

{

if (!seek)

{

return;

}

if (fseek(jitSrcFilePtr, 0, SEEK_SET) != 0)

{

printf("Compiler::compDspSrcLinesByLineNum: fseek returned an error.\n");

}

jitCurSrcLine = 0;

}

if (!seek)

{

printf(";\n");

}

do

{

char temp[128];

size_t llen;

if (!fgets(temp, sizeof(temp), jitSrcFilePtr))

{

return;

}

if (seek)

{

continue;

}

llen = strlen(temp);

if (llen && temp[llen - 1] == '\n')

{

temp[llen - 1] = 0;

}

printf("; %s\n", temp);

} while (++jitCurSrcLine < line);

if (!seek)

{

printf(";\n");

}

}

/*****************************************************************************/

void Compiler::compDspSrcLinesByNativeIP(UNATIVE_OFFSET curIP)

{

static IPmappingDsc* nextMappingDsc;

static unsigned lastLine;

if (!opts.dspLines)

{

return;

}

if (curIP == 0)

{

if (genIPmappingList)

{

nextMappingDsc = genIPmappingList;

lastLine = jitGetILoffs(nextMappingDsc->ipmdILoffsx);

unsigned firstLine = jitGetILoffs(nextMappingDsc->ipmdILoffsx);

unsigned earlierLine = (firstLine < 5) ? 0 : firstLine - 5;

compDspSrcLinesByLineNum(earlierLine, true); // display previous 5 lines

compDspSrcLinesByLineNum(firstLine, false);

}

else

{

nextMappingDsc = nullptr;

}

return;

}

if (nextMappingDsc)

{

UNATIVE_OFFSET offset = nextMappingDsc->ipmdNativeLoc.CodeOffset(GetEmitter());

if (offset <= curIP)

{

IL_OFFSET nextOffs = jitGetILoffs(nextMappingDsc->ipmdILoffsx);

if (lastLine < nextOffs)

{

compDspSrcLinesByLineNum(nextOffs);

}

else

{

// This offset corresponds to a previous line. Rewind to that line

compDspSrcLinesByLineNum(nextOffs - 2, true);

compDspSrcLinesByLineNum(nextOffs);

}

lastLine = nextOffs;

nextMappingDsc = nextMappingDsc->ipmdNext;

}

}

}

/*****************************************************************************/

#endif // DEBUG

/*****************************************************************************/

#if defined(DEBUG) || MEASURE_NODE_SIZE || MEASURE_BLOCK_SIZE || DISPLAY_SIZES || CALL_ARG_STATS

static unsigned genMethodCnt; // total number of methods JIT'ted

unsigned genMethodICnt; // number of interruptible methods

unsigned genMethodNCnt; // number of non-interruptible methods

static unsigned genSmallMethodsNeedingExtraMemoryCnt = 0;

#endif

/*****************************************************************************/

#if MEASURE_NODE_SIZE

NodeSizeStats genNodeSizeStats;

NodeSizeStats genNodeSizeStatsPerFunc;

unsigned genTreeNcntHistBuckets[] = {10, 20, 30, 40, 50, 100, 200, 300, 400, 500, 1000, 5000, 10000, 0};

Histogram genTreeNcntHist(genTreeNcntHistBuckets);

unsigned genTreeNsizHistBuckets[] = {1000, 5000, 10000, 50000, 100000, 500000, 1000000, 0};

Histogram genTreeNsizHist(genTreeNsizHistBuckets);

#endif // MEASURE_NODE_SIZE

/*****************************************************************************/

#if MEASURE_MEM_ALLOC

unsigned memAllocHistBuckets[] = {64, 128, 192, 256, 512, 1024, 4096, 8192, 0};

Histogram memAllocHist(memAllocHistBuckets);

unsigned memUsedHistBuckets[] = {16, 32, 64, 128, 192, 256, 512, 1024, 4096, 8192, 0};

Histogram memUsedHist(memUsedHistBuckets);

#endif // MEASURE_MEM_ALLOC

/*****************************************************************************

*

* Variables to keep track of total code amounts.

*/

#if DISPLAY_SIZES

size_t grossVMsize; // Total IL code size

size_t grossNCsize; // Native code + data size

size_t totalNCsize; // Native code + data + GC info size (TODO-Cleanup: GC info size only accurate for JIT32_GCENCODER)

size_t gcHeaderISize; // GC header size: interruptible methods

size_t gcPtrMapISize; // GC pointer map size: interruptible methods

size_t gcHeaderNSize; // GC header size: non-interruptible methods

size_t gcPtrMapNSize; // GC pointer map size: non-interruptible methods

#endif // DISPLAY_SIZES

/*****************************************************************************

*

* Variables to keep track of argument counts.

*/

#if CALL_ARG_STATS

unsigned argTotalCalls;

unsigned argHelperCalls;

unsigned argStaticCalls;

unsigned argNonVirtualCalls;

unsigned argVirtualCalls;

unsigned argTotalArgs; // total number of args for all calls (including objectPtr)

unsigned argTotalDWordArgs;

unsigned argTotalLongArgs;

unsigned argTotalFloatArgs;

unsigned argTotalDoubleArgs;

unsigned argTotalRegArgs;

unsigned argTotalTemps;

unsigned argTotalLclVar;

unsigned argTotalDeferred;

unsigned argTotalConst;

unsigned argTotalObjPtr;

unsigned argTotalGTF_ASGinArgs;

unsigned argMaxTempsPerMethod;

unsigned argCntBuckets[] = {0, 1, 2, 3, 4, 5, 6, 10, 0};

Histogram argCntTable(argCntBuckets);

unsigned argDWordCntBuckets[] = {0, 1, 2, 3, 4, 5, 6, 10, 0};

Histogram argDWordCntTable(argDWordCntBuckets);

unsigned argDWordLngCntBuckets[] = {0, 1, 2, 3, 4, 5, 6, 10, 0};

Histogram argDWordLngCntTable(argDWordLngCntBuckets);

unsigned argTempsCntBuckets[] = {0, 1, 2, 3, 4, 5, 6, 10, 0};

Histogram argTempsCntTable(argTempsCntBuckets);

#endif // CALL_ARG_STATS

/*****************************************************************************

*

* Variables to keep track of basic block counts.

*/

#if COUNT_BASIC_BLOCKS

// --------------------------------------------------

// Basic block count frequency table:

// --------------------------------------------------

// <= 1 ===> 26872 count ( 56% of total)

// 2 .. 2 ===> 669 count ( 58% of total)

// 3 .. 3 ===> 4687 count ( 68% of total)

// 4 .. 5 ===> 5101 count ( 78% of total)

// 6 .. 10 ===> 5575 count ( 90% of total)

// 11 .. 20 ===> 3028 count ( 97% of total)

// 21 .. 50 ===> 1108 count ( 99% of total)

// 51 .. 100 ===> 182 count ( 99% of total)

// 101 .. 1000 ===> 34 count (100% of total)

// 1001 .. 10000 ===> 0 count (100% of total)

// --------------------------------------------------

unsigned bbCntBuckets[] = {1, 2, 3, 5, 10, 20, 50, 100, 1000, 10000, 0};

Histogram bbCntTable(bbCntBuckets);

/* Histogram for the IL opcode size of methods with a single basic block */

unsigned bbSizeBuckets[] = {1, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 0};

Histogram bbOneBBSizeTable(bbSizeBuckets);

#endif // COUNT_BASIC_BLOCKS

/*****************************************************************************

*

* Used by optFindNaturalLoops to gather statistical information such as

* - total number of natural loops

* - number of loops with 1, 2, ... exit conditions

* - number of loops that have an iterator (for like)

* - number of loops that have a constant iterator

*/

#if COUNT_LOOPS

unsigned totalLoopMethods; // counts the total number of methods that have natural loops

unsigned maxLoopsPerMethod; // counts the maximum number of loops a method has

unsigned totalLoopOverflows; // # of methods that identified more loops than we can represent

unsigned totalLoopCount; // counts the total number of natural loops

unsigned totalUnnatLoopCount; // counts the total number of (not-necessarily natural) loops

unsigned totalUnnatLoopOverflows; // # of methods that identified more unnatural loops than we can represent

unsigned iterLoopCount; // counts the # of loops with an iterator (for like)

unsigned simpleTestLoopCount; // counts the # of loops with an iterator and a simple loop condition (iter < const)

unsigned constIterLoopCount; // counts the # of loops with a constant iterator (for like)

bool hasMethodLoops; // flag to keep track if we already counted a method as having loops

unsigned loopsThisMethod; // counts the number of loops in the current method

bool loopOverflowThisMethod; // True if we exceeded the max # of loops in the method.

/* Histogram for number of loops in a method */

unsigned loopCountBuckets[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 0};

Histogram loopCountTable(loopCountBuckets);

/* Histogram for number of loop exits */

unsigned loopExitCountBuckets[] = {0, 1, 2, 3, 4, 5, 6, 0};

Histogram loopExitCountTable(loopExitCountBuckets);

#endif // COUNT_LOOPS

//------------------------------------------------------------------------

// getJitGCType: Given the VM's CorInfoGCType convert it to the JIT's var_types

//

// Arguments:

// gcType - an enum value that originally came from an element

// of the BYTE[] returned from getClassGClayout()

//

// Return Value:

// The corresponsing enum value from the JIT's var_types

//

// Notes:

// The gcLayout of each field of a struct is returned from getClassGClayout()

// as a BYTE[] but each BYTE element is actually a CorInfoGCType value

// Note when we 'know' that there is only one element in theis array

// the JIT will often pass the address of a single BYTE, instead of a BYTE[]

//

var_types Compiler::getJitGCType(BYTE gcType)

{

var_types result = TYP_UNKNOWN;

CorInfoGCType corInfoType = (CorInfoGCType)gcType;

if (corInfoType == TYPE_GC_NONE)

{

result = TYP_I_IMPL;

}

else if (corInfoType == TYPE_GC_REF)

{

result = TYP_REF;

}

else if (corInfoType == TYPE_GC_BYREF)

{

result = TYP_BYREF;

}

else

{

noway_assert(!"Bad value of 'gcType'");

}

return result;

}

#ifdef ARM_SOFTFP

//---------------------------------------------------------------------------

// IsSingleFloat32Struct:

// Check if the given struct type contains only one float32 value type

//

// Arguments:

// clsHnd - the handle for the struct type

//

// Return Value:

// true if the given struct type contains only one float32 value type,

// false otherwise.

//

bool Compiler::isSingleFloat32Struct(CORINFO_CLASS_HANDLE clsHnd)

{

for (;;)

{

// all of class chain must be of value type and must have only one field

if (!info.compCompHnd->isValueClass(clsHnd) || info.compCompHnd->getClassNumInstanceFields(clsHnd) != 1)

{

return false;

}

CORINFO_CLASS_HANDLE* pClsHnd = &clsHnd;

CORINFO_FIELD_HANDLE fldHnd = info.compCompHnd->getFieldInClass(clsHnd, 0);

CorInfoType fieldType = info.compCompHnd->getFieldType(fldHnd, pClsHnd);

switch (fieldType)

{

case CORINFO_TYPE_VALUECLASS:

clsHnd = *pClsHnd;

break;

case CORINFO_TYPE_FLOAT:

return true;

default:

return false;

}

}

}

#endif // ARM_SOFTFP

//-----------------------------------------------------------------------------

// getPrimitiveTypeForStruct:

// Get the "primitive" type that is is used for a struct

// of size 'structSize'.

// We examine 'clsHnd' to check the GC layout of the struct and

// return TYP_REF for structs that simply wrap an object.

// If the struct is a one element HFA/HVA, we will return the

// proper floating point or vector type.

//

// Arguments:

// structSize - the size of the struct type, cannot be zero

// clsHnd - the handle for the struct type, used when may have

// an HFA or if we need the GC layout for an object ref.

//

// Return Value:

// The primitive type (i.e. byte, short, int, long, ref, float, double)

// used to pass or return structs of this size.

// If we shouldn't use a "primitive" type then TYP_UNKNOWN is returned.

// Notes:

// For 32-bit targets (X86/ARM32) the 64-bit TYP_LONG type is not

// considered a primitive type by this method.

// So a struct that wraps a 'long' is passed and returned in the

// same way as any other 8-byte struct

// For ARM32 if we have an HFA struct that wraps a 64-bit double

// we will return TYP_DOUBLE.

// For vector calling conventions, a vector is considered a "primitive"

// type, as it is passed in a single register.

//

var_types Compiler::getPrimitiveTypeForStruct(unsigned structSize, CORINFO_CLASS_HANDLE clsHnd, bool isVarArg)

{

assert(structSize != 0);

var_types useType = TYP_UNKNOWN;

// Start by determining if we have an HFA/HVA with a single element.

#ifdef FEATURE_HFA

#if defined(_TARGET_WINDOWS_) && defined(_TARGET_ARM64_)

// Arm64 Windows VarArg methods arguments will not classify HFA types, they will need to be treated

// as if they are not HFA types.

if (!isVarArg)

#endif // defined(_TARGET_WINDOWS_) && defined(_TARGET_ARM64_)

{

switch (structSize)

{

case 4:

case 8:

#ifdef _TARGET_ARM64_

case 16:

#endif // _TARGET_ARM64_

{

var_types hfaType;

#ifdef ARM_SOFTFP

// For ARM_SOFTFP, HFA is unsupported so we need to check in another way.

// This matters only for size-4 struct because bigger structs would be processed with RetBuf.

if (isSingleFloat32Struct(clsHnd))

{

hfaType = TYP_FLOAT;

}

#else // !ARM_SOFTFP

hfaType = GetHfaType(clsHnd);

#endif // ARM_SOFTFP

// We're only interested in the case where the struct size is equal to the size of the hfaType.

if (varTypeIsValidHfaType(hfaType))

{

if (genTypeSize(hfaType) == structSize)

{

useType = hfaType;

}

else

{

return TYP_UNKNOWN;

}

}

}

}

if (useType != TYP_UNKNOWN)

{

return useType;

}

}

#endif // FEATURE_HFA

// Now deal with non-HFA/HVA structs.

switch (structSize)

{

case 1:

useType = TYP_BYTE;

break;

case 2:

useType = TYP_SHORT;

break;

#if !defined(_TARGET_XARCH_) || defined(UNIX_AMD64_ABI)

case 3:

useType = TYP_INT;

break;

#endif // !_TARGET_XARCH_ || UNIX_AMD64_ABI

#ifdef _TARGET_64BIT_

case 4:

// We dealt with the one-float HFA above. All other 4-byte structs are handled as INT.

useType = TYP_INT;

break;

#if !defined(_TARGET_XARCH_) || defined(UNIX_AMD64_ABI)

case 5:

case 6:

case 7:

useType = TYP_I_IMPL;

break;

#endif // !_TARGET_XARCH_ || UNIX_AMD64_ABI

#endif // _TARGET_64BIT_

case TARGET_POINTER_SIZE:

{

BYTE gcPtr = 0;

// Check if this pointer-sized struct is wrapping a GC object

info.compCompHnd->getClassGClayout(clsHnd, &gcPtr);

useType = getJitGCType(gcPtr);

}

break;

default:

useType = TYP_UNKNOWN;

break;

}

return useType;

}

//-----------------------------------------------------------------------------

// getArgTypeForStruct:

// Get the type that is used to pass values of the given struct type.

// If you have already retrieved the struct size then it should be

// passed as the optional fourth argument, as this allows us to avoid

// an extra call to getClassSize(clsHnd)

//

// Arguments:

// clsHnd - the handle for the struct type

// wbPassStruct - An "out" argument with information about how

// the struct is to be passed

// isVarArg - is vararg, used to ignore HFA types for Arm64 windows varargs

// structSize - the size of the struct type,

// or zero if we should call getClassSize(clsHnd)

//

// Return Value:

// For wbPassStruct you can pass a 'nullptr' and nothing will be written

// or returned for that out parameter.

// When *wbPassStruct is SPK_PrimitiveType this method's return value

// is the primitive type used to pass the struct.

// When *wbPassStruct is SPK_ByReference this method's return value

// is always TYP_UNKNOWN and the struct type is passed by reference to a copy

// When *wbPassStruct is SPK_ByValue or SPK_ByValueAsHfa this method's return value

// is always TYP_STRUCT and the struct type is passed by value either

// using multiple registers or on the stack.

//

// Assumptions:

// The size must be the size of the given type.

// The given class handle must be for a value type (struct).

//

// Notes:

// About HFA types:

// When the clsHnd is a one element HFA type we return the appropriate

// floating point primitive type and *wbPassStruct is SPK_PrimitiveType

// If there are two or more elements in the HFA type then the this method's

// return value is TYP_STRUCT and *wbPassStruct is SPK_ByValueAsHfa

//

var_types Compiler::getArgTypeForStruct(CORINFO_CLASS_HANDLE clsHnd,

structPassingKind* wbPassStruct,

bool isVarArg,

unsigned structSize)

{

var_types useType = TYP_UNKNOWN;

structPassingKind howToPassStruct = SPK_Unknown; // We must change this before we return

assert(structSize != 0);

// Determine if we can pass the struct as a primitive type.

// Note that on x86 we never pass structs as primitive types (unless the VM unwraps them for us).

#ifndef _TARGET_X86_

#ifdef UNIX_AMD64_ABI

// An 8-byte struct may need to be passed in a floating point register

// So we always consult the struct "Classifier" routine

//

SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR structDesc;

eeGetSystemVAmd64PassStructInRegisterDescriptor(clsHnd, &structDesc);

if (structDesc.passedInRegisters && (structDesc.eightByteCount != 1))

{

// We can't pass this as a primitive type.

}

else if (structDesc.eightByteClassifications[0] == SystemVClassificationTypeSSE)

{

// If this is passed as a floating type, use that.

// Otherwise, we'll use the general case - we don't want to use the "EightByteType"

// directly, because it returns `TYP_INT` for any integral type <= 4 bytes, and

// we need to preserve small types.

useType = GetEightByteType(structDesc, 0);

}

else

#endif // UNIX_AMD64_ABI

// The largest arg passed in a single register is MAX_PASS_SINGLEREG_BYTES,

// so we can skip calling getPrimitiveTypeForStruct when we

// have a struct that is larger than that.

//

if (structSize <= MAX_PASS_SINGLEREG_BYTES)

{

// We set the "primitive" useType based upon the structSize

// and also examine the clsHnd to see if it is an HFA of count one

useType = getPrimitiveTypeForStruct(structSize, clsHnd, isVarArg);

}

#endif // !_TARGET_X86_

// Did we change this struct type into a simple "primitive" type?

//

if (useType != TYP_UNKNOWN)

{

// Yes, we should use the "primitive" type in 'useType'

howToPassStruct = SPK_PrimitiveType;

}

else // We can't replace the struct with a "primitive" type

{

// See if we can pass this struct by value, possibly in multiple registers

// or if we should pass it by reference to a copy

//

if (structSize <= MAX_PASS_MULTIREG_BYTES)

{

// Structs that are HFA/HVA's are passed by value in multiple registers.

// Arm64 Windows VarArg methods arguments will not classify HFA/HVA types, they will need to be treated

// as if they are not HFA/HVA types.

var_types hfaType;

#if defined(_TARGET_WINDOWS_) && defined(_TARGET_ARM64_)

if (isVarArg)

{

hfaType = TYP_UNDEF;

}

else

#endif // defined(_TARGET_WINDOWS_) && defined(_TARGET_ARM64_)

{

hfaType = GetHfaType(clsHnd);

}

if (varTypeIsValidHfaType(hfaType))

{

// HFA's of count one should have been handled by getPrimitiveTypeForStruct

assert(GetHfaCount(clsHnd) >= 2);

// setup wbPassType and useType indicate that this is passed by value as an HFA

// using multiple registers

// (when all of the parameters registers are used, then the stack will be used)

howToPassStruct = SPK_ByValueAsHfa;

useType = TYP_STRUCT;

}

else // Not an HFA struct type

{

#ifdef UNIX_AMD64_ABI

// The case of (structDesc.eightByteCount == 1) should have already been handled

if ((structDesc.eightByteCount > 1) || !structDesc.passedInRegisters)

{

// setup wbPassType and useType indicate that this is passed by value in multiple registers

// (when all of the parameters registers are used, then the stack will be used)

howToPassStruct = SPK_ByValue;

useType = TYP_STRUCT;

}

else

{

assert(structDesc.eightByteCount == 0);

// Otherwise we pass this struct by reference to a copy

// setup wbPassType and useType indicate that this is passed using one register

// (by reference to a copy)

howToPassStruct = SPK_ByReference;

useType = TYP_UNKNOWN;

}

#elif defined(_TARGET_ARM64_)

// Structs that are pointer sized or smaller should have been handled by getPrimitiveTypeForStruct

assert(structSize > TARGET_POINTER_SIZE);

// On ARM64 structs that are 9-16 bytes are passed by value in multiple registers

//

if (structSize <= (TARGET_POINTER_SIZE * 2))

{

// setup wbPassType and useType indicate that this is passed by value in multiple registers

// (when all of the parameters registers are used, then the stack will be used)

howToPassStruct = SPK_ByValue;

useType = TYP_STRUCT;

}

else // a structSize that is 17-32 bytes in size

{

// Otherwise we pass this struct by reference to a copy

// setup wbPassType and useType indicate that this is passed using one register

// (by reference to a copy)

howToPassStruct = SPK_ByReference;

useType = TYP_UNKNOWN;

}

#elif defined(_TARGET_X86_) || defined(_TARGET_ARM_)

// Otherwise we pass this struct by value on the stack

// setup wbPassType and useType indicate that this is passed by value according to the X86/ARM32 ABI

howToPassStruct = SPK_ByValue;

useType = TYP_STRUCT;

#else // _TARGET_XXX_

noway_assert(!"Unhandled TARGET in getArgTypeForStruct (with FEATURE_MULTIREG_ARGS=1)");

#endif // _TARGET_XXX_

}

}

else // (structSize > MAX_PASS_MULTIREG_BYTES)

{

// We have a (large) struct that can't be replaced with a "primitive" type

// and can't be passed in multiple registers

CLANG_FORMAT_COMMENT_ANCHOR;

#if defined(_TARGET_X86_) || defined(_TARGET_ARM_) || defined(UNIX_AMD64_ABI)

// Otherwise we pass this struct by value on the stack

// setup wbPassType and useType indicate that this is passed by value according to the X86/ARM32 ABI

howToPassStruct = SPK_ByValue;

useType = TYP_STRUCT;

#elif defined(_TARGET_AMD64_) || defined(_TARGET_ARM64_)

// Otherwise we pass this struct by reference to a copy

// setup wbPassType and useType indicate that this is passed using one register (by reference to a copy)

howToPassStruct = SPK_ByReference;

useType = TYP_UNKNOWN;

#else // _TARGET_XXX_

noway_assert(!"Unhandled TARGET in getArgTypeForStruct");

#endif // _TARGET_XXX_

}

}

// 'howToPassStruct' must be set to one of the valid values before we return

assert(howToPassStruct != SPK_Unknown);

if (wbPassStruct != nullptr)

{

*wbPassStruct = howToPassStruct;

}

return useType;

}

//-----------------------------------------------------------------------------

// getReturnTypeForStruct:

// Get the type that is used to return values of the given struct type.

// If you have already retrieved the struct size then it should be

// passed as the optional third argument, as this allows us to avoid

// an extra call to getClassSize(clsHnd)

//

// Arguments:

// clsHnd - the handle for the struct type

// wbReturnStruct - An "out" argument with information about how

// the struct is to be returned

// structSize - the size of the struct type,

// or zero if we should call getClassSize(clsHnd)

//

// Return Value:

// For wbReturnStruct you can pass a 'nullptr' and nothing will be written

// or returned for that out parameter.

// When *wbReturnStruct is SPK_PrimitiveType this method's return value

// is the primitive type used to return the struct.

// When *wbReturnStruct is SPK_ByReference this method's return value

// is always TYP_UNKNOWN and the struct type is returned using a return buffer

// When *wbReturnStruct is SPK_ByValue or SPK_ByValueAsHfa this method's return value

// is always TYP_STRUCT and the struct type is returned using multiple registers.

//

// Assumptions:

// The size must be the size of the given type.

// The given class handle must be for a value type (struct).

//

// Notes:

// About HFA types:

// When the clsHnd is a one element HFA type then this method's return

// value is the appropriate floating point primitive type and

// *wbReturnStruct is SPK_PrimitiveType.

// If there are two or more elements in the HFA type and the target supports

// multireg return types then the return value is TYP_STRUCT and

// *wbReturnStruct is SPK_ByValueAsHfa.

// Additionally if there are two or more elements in the HFA type and

// the target doesn't support multreg return types then it is treated

// as if it wasn't an HFA type.

// About returning TYP_STRUCT:

// Whenever this method's return value is TYP_STRUCT it always means

// that multiple registers are used to return this struct.

//

var_types Compiler::getReturnTypeForStruct(CORINFO_CLASS_HANDLE clsHnd,

structPassingKind* wbReturnStruct /* = nullptr */,

unsigned structSize /* = 0 */)

{

var_types useType = TYP_UNKNOWN;

structPassingKind howToReturnStruct = SPK_Unknown; // We must change this before we return

bool canReturnInRegister = true;

assert(clsHnd != NO_CLASS_HANDLE);

if (structSize == 0)

{

structSize = info.compCompHnd->getClassSize(clsHnd);

}

assert(structSize > 0);

#ifdef UNIX_AMD64_ABI

// An 8-byte struct may need to be returned in a floating point register

// So we always consult the struct "Classifier" routine

//

SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR structDesc;

eeGetSystemVAmd64PassStructInRegisterDescriptor(clsHnd, &structDesc);

if (structDesc.eightByteCount == 1)

{

assert(structSize <= sizeof(double));

assert(structDesc.passedInRegisters);

if (structDesc.eightByteClassifications[0] == SystemVClassificationTypeSSE)

{

// If this is returned as a floating type, use that.

// Otherwise, leave as TYP_UNKONWN and we'll sort things out below.

useType = GetEightByteType(structDesc, 0);

howToReturnStruct = SPK_PrimitiveType;

}

}

else

{

// Return classification is not always size based...

canReturnInRegister = structDesc.passedInRegisters;

}

#endif // UNIX_AMD64_ABI

// Check for cases where a small struct is returned in a register

// via a primitive type.

//

// The largest "primitive type" is MAX_PASS_SINGLEREG_BYTES

// so we can skip calling getPrimitiveTypeForStruct when we

// have a struct that is larger than that.

if (canReturnInRegister && (useType == TYP_UNKNOWN) && (structSize <= MAX_PASS_SINGLEREG_BYTES))

{

// We set the "primitive" useType based upon the structSize

// and also examine the clsHnd to see if it is an HFA of count one

//

// The ABI for struct returns in varArg methods, is same as the normal case,

// so pass false for isVararg

useType = getPrimitiveTypeForStruct(structSize, clsHnd, /*isVararg=*/false);

if (useType != TYP_UNKNOWN)

{

if (structSize == genTypeSize(useType))

{

// Currently: 1, 2, 4, or 8 byte structs

howToReturnStruct = SPK_PrimitiveType;

}

else

{

// Currently: 3, 5, 6, or 7 byte structs

assert(structSize < genTypeSize(useType));

howToReturnStruct = SPK_EnclosingType;

}

}

}

#ifdef _TARGET_64BIT_

// Note this handles an odd case when FEATURE_MULTIREG_RET is disabled and HFAs are enabled

//

// getPrimitiveTypeForStruct will return TYP_UNKNOWN for a struct that is an HFA of two floats

// because when HFA are enabled, normally we would use two FP registers to pass or return it

//

// But if we don't have support for multiple register return types, we have to change this.

// Since what we have is an 8-byte struct (float + float) we change useType to TYP_I_IMPL

// so that the struct is returned instead using an 8-byte integer register.

//

if ((FEATURE_MULTIREG_RET == 0) && (useType == TYP_UNKNOWN) && (structSize == (2 * sizeof(float))) && IsHfa(clsHnd))

{

useType = TYP_I_IMPL;