{

*cycleOut = __rdtsc();

return true;

{

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;

{

SYSTEMTIME tim;

GetSystemTime(&tim);

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

{

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);

{

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");

}

{

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;

}

}

{

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;

{

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;

}

}

{

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;

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;

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;