compiler.cpp

// 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.
#defineCOLUMN_OPCODE30
#defineCOLUMN_OPERANDS (COLUMN_OPCODE + 25)
#defineCOLUMN_KINDS110
#defineCOLUMN_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>
inlinebool_our_GetThreadCycles(unsigned __int64* cycleOut)
{
 *cycleOut = __rdtsc();
returntrue;
}

#elif defined(__GNUC__)

inlinebool_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);
returntrue;
}

#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
/*****************************************************************************/
inlineunsignedgetCurTime()
{
 SYSTEMTIME tim;

GetSystemTime(&tim);

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

/*****************************************************************************/
#ifdef DEBUG
/*****************************************************************************/

static FILE* jitSrcFilePtr;

staticunsigned jitCurSrcLine;

voidCompiler::JitLogEE(unsigned level, constchar* 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);
}

voidCompiler::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");
 }
}

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

voidCompiler::compDspSrcLinesByNativeIP(UNATIVE_OFFSET curIP)
{
static IPmappingDsc* nextMappingDsc;
staticunsigned 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

staticunsigned genMethodCnt; // total number of methods JIT'ted
unsigned genMethodICnt; // number of interruptible methods
unsigned genMethodNCnt; // number of non-interruptible methods
staticunsigned 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;
 }
elseif (corInfoType == TYPE_GC_REF)
 {
 result = TYP_REF;
 }
elseif (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.
//

boolCompiler::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)
 {
returnfalse;
 }

 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:
returntrue;

default:
returnfalse;
 }
 }
}
#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)
 {
case4:
case8:
#ifdef _TARGET_ARM64_
case16:
#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)
 {
case1:
 useType = TYP_BYTE;
break;

case2:
 useType = TYP_SHORT;
break;

#if !defined(_TARGET_XARCH_) || defined(UNIX_AMD64_ABI)
case3:
 useType = TYP_INT;
break;

#endif// !_TARGET_XARCH_ || UNIX_AMD64_ABI

#ifdef _TARGET_64BIT_
case4:
// 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)
case5:
case6:
case7:
 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.
 }
elseif (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;