diff --git a/src/coreclr/jit/CMakeLists.txt b/src/coreclr/jit/CMakeLists.txt index e468b3a59c7c75..21bc23914c3fee 100644 --- a/src/coreclr/jit/CMakeLists.txt +++ b/src/coreclr/jit/CMakeLists.txt @@ -228,7 +228,6 @@ if (CLR_CMAKE_TARGET_WIN32) regalloc.h register_arg_convention.h register.h - reglist.h regset.h sideeffects.h simd.h diff --git a/src/coreclr/jit/compiler.cpp b/src/coreclr/jit/compiler.cpp index a26a003a455fb9..823b25e56ab682 100644 --- a/src/coreclr/jit/compiler.cpp +++ b/src/coreclr/jit/compiler.cpp @@ -9252,10 +9252,6 @@ void cTreeFlags(Compiler* comp, GenTree* tree) { chars += printf("[RELOP_JMP_USED]"); } - if (tree->gtFlags & GTF_RELOP_QMARK) - { - chars += printf("[RELOP_QMARK]"); - } break; case GT_QMARK: diff --git a/src/coreclr/jit/compiler.h b/src/coreclr/jit/compiler.h index befb4a6f60b7b7..aac7301994fcbd 100644 --- a/src/coreclr/jit/compiler.h +++ b/src/coreclr/jit/compiler.h @@ -41,7 +41,6 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX #include "jitexpandarray.h" #include "tinyarray.h" #include "valuenum.h" -#include "reglist.h" #include "jittelemetry.h" #include "namedintrinsiclist.h" #ifdef LATE_DISASM @@ -3419,8 +3418,6 @@ class Compiler // before they have been set.) bool gtComplexityExceeds(GenTree** tree, unsigned limit); - bool gtCompareTree(GenTree* op1, GenTree* op2); - GenTree* gtReverseCond(GenTree* tree); bool gtHasRef(GenTree* tree, ssize_t lclNum, bool defOnly); @@ -3606,9 +3603,6 @@ class Compiler typedef fgWalkResult(fgWalkPreFn)(GenTree** pTree, fgWalkData* data); typedef fgWalkResult(fgWalkPostFn)(GenTree** pTree, fgWalkData* data); -#ifdef DEBUG - static fgWalkPreFn gtAssertColonCond; -#endif static fgWalkPreFn gtMarkColonCond; static fgWalkPreFn gtClearColonCond; @@ -3775,15 +3769,6 @@ class Compiler // where it is used to detect tail-call chains. unsigned lvaRetAddrVar; -#ifdef TARGET_ARM - // On architectures whose ABIs allow structs to be passed in registers, struct promotion will sometimes - // require us to "rematerialize" a struct from it's separate constituent field variables. Packing several sub-word - // field variables into an argument register is a hard problem. It's easier to reserve a word of memory into which - // such field can be copied, after which the assembled memory word can be read into the register. We will allocate - // this variable to be this scratch word whenever struct promotion occurs. - unsigned lvaPromotedStructAssemblyScratchVar; -#endif // TARGET_ARM - #if defined(DEBUG) && defined(TARGET_XARCH) unsigned lvaReturnSpCheck; // Stores SP to confirm it is not corrupted on return. @@ -7990,35 +7975,6 @@ class Compiler #if defined(DEBUG) || defined(FEATURE_JIT_METHOD_PERF) || defined(FEATURE_SIMD) || defined(TRACK_LSRA_STATS) - bool IsSuperPMIException(unsigned code) - { - // Copied from NDP\clr\src\ToolBox\SuperPMI\SuperPMI-Shared\ErrorHandling.h - - const unsigned EXCEPTIONCODE_DebugBreakorAV = 0xe0421000; - const unsigned EXCEPTIONCODE_MC = 0xe0422000; - const unsigned EXCEPTIONCODE_LWM = 0xe0423000; - const unsigned EXCEPTIONCODE_SASM = 0xe0424000; - const unsigned EXCEPTIONCODE_SSYM = 0xe0425000; - const unsigned EXCEPTIONCODE_CALLUTILS = 0xe0426000; - const unsigned EXCEPTIONCODE_TYPEUTILS = 0xe0427000; - const unsigned EXCEPTIONCODE_ASSERT = 0xe0440000; - - switch (code) - { - case EXCEPTIONCODE_DebugBreakorAV: - case EXCEPTIONCODE_MC: - case EXCEPTIONCODE_LWM: - case EXCEPTIONCODE_SASM: - case EXCEPTIONCODE_SSYM: - case EXCEPTIONCODE_CALLUTILS: - case EXCEPTIONCODE_TYPEUTILS: - case EXCEPTIONCODE_ASSERT: - return true; - default: - return false; - } - } - const char* eeGetMethodName(CORINFO_METHOD_HANDLE hnd, const char** className); const char* eeGetMethodFullName(CORINFO_METHOD_HANDLE hnd); unsigned compMethodHash(CORINFO_METHOD_HANDLE methodHandle); @@ -8260,7 +8216,6 @@ class Compiler static CORINFO_METHOD_HANDLE eeFindHelper(unsigned helper); static CorInfoHelpFunc eeGetHelperNum(CORINFO_METHOD_HANDLE method); - static fgWalkPreFn CountSharedStaticHelper; static bool IsSharedStaticHelper(GenTree* tree); static bool IsGcSafePoint(GenTree* tree); diff --git a/src/coreclr/jit/compiler.hpp b/src/coreclr/jit/compiler.hpp index 0c446f2020d0b9..acc94384e29e10 100644 --- a/src/coreclr/jit/compiler.hpp +++ b/src/coreclr/jit/compiler.hpp @@ -3610,17 +3610,6 @@ inline CorInfoHelpFunc Compiler::eeGetHelperNum(CORINFO_METHOD_HANDLE method) return ((CorInfoHelpFunc)(((size_t)method) >> 2)); } -inline Compiler::fgWalkResult Compiler::CountSharedStaticHelper(GenTree** pTree, fgWalkData* data) -{ - if (Compiler::IsSharedStaticHelper(*pTree)) - { - int* pCount = (int*)data->pCallbackData; - (*pCount)++; - } - - return WALK_CONTINUE; -} - // TODO-Cleanup: Replace calls to IsSharedStaticHelper with new HelperCallProperties // diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp index 90093f9e7bba6c..1449ea591c9700 100644 --- a/src/coreclr/jit/gentree.cpp +++ b/src/coreclr/jit/gentree.cpp @@ -5972,8 +5972,7 @@ GenTree* Compiler::gtNewOperNode(genTreeOps oper, var_types type, GenTree* op1, GenTreeQmark* Compiler::gtNewQmarkNode(var_types type, GenTree* cond, GenTreeColon* colon) { - compQmarkUsed = true; - cond->gtFlags |= GTF_RELOP_QMARK; + compQmarkUsed = true; GenTreeQmark* result = new (this, GT_QMARK) GenTreeQmark(type, cond, colon); #ifdef DEBUG if (compQmarkRationalized) @@ -8149,18 +8148,6 @@ GenTree* Compiler::gtCloneExpr( /* GTF_NODE_MASK should not be propagated from 'tree' to 'copy' */ addFlags &= ~GTF_NODE_MASK; #endif - // Some other flags depend on the context of the expression, and should not be preserved. - // For example, GTF_RELOP_QMARK: - if (copy->OperKind() & GTK_RELOP) - { - addFlags &= ~GTF_RELOP_QMARK; - } - // On the other hand, if we're creating such a context, restore this flag. - if (copy->OperGet() == GT_QMARK) - { - copy->AsOp()->gtOp1->gtFlags |= GTF_RELOP_QMARK; - } - copy->gtFlags |= addFlags; // Update side effect flags since they may be different from the source side effect flags. @@ -8235,11 +8222,6 @@ GenTreeCall* Compiler::gtCloneExprCallHelper(GenTreeCall* tree, argsTail = &((*argsTail)->NextRef()); } -#if !FEATURE_FIXED_OUT_ARGS - copy->regArgList = tree->regArgList; - copy->regArgListCount = tree->regArgListCount; -#endif - // The call sig comes from the EE and doesn't change throughout the compilation process, meaning // we only really need one physical copy of it. Therefore a shallow pointer copy will suffice. // (Note that this still holds even if the tree we are cloning was created by an inlinee compiler, @@ -8649,83 +8631,6 @@ Compiler::fgWalkResult Compiler::fgUpdateSideEffectsPost(GenTree** pTree, fgWalk return WALK_CONTINUE; } -/***************************************************************************** - * - * Compares two trees and returns true when both trees are the same. - * Instead of fully comparing the two trees this method can just return false. - * Thus callers should not assume that the trees are different when false is returned. - * Only when true is returned can the caller perform code optimizations. - * The current implementation only compares a limited set of LEAF/CONST node - * and returns false for all othere trees. - */ -bool Compiler::gtCompareTree(GenTree* op1, GenTree* op2) -{ - /* Make sure that both trees are of the same GT node kind */ - if (op1->OperGet() != op2->OperGet()) - { - return false; - } - - /* Make sure that both trees are returning the same type */ - if (op1->gtType != op2->gtType) - { - return false; - } - - /* Figure out what kind of a node we have */ - - genTreeOps oper = op1->OperGet(); - unsigned kind = op1->OperKind(); - - /* Is this a constant or leaf node? */ - - if (kind & (GTK_CONST | GTK_LEAF)) - { - switch (oper) - { - case GT_CNS_INT: - if ((op1->AsIntCon()->gtIconVal == op2->AsIntCon()->gtIconVal) && GenTree::SameIconHandleFlag(op1, op2)) - { - return true; - } - break; - - case GT_CNS_LNG: - if (op1->AsLngCon()->gtLconVal == op2->AsLngCon()->gtLconVal) - { - return true; - } - break; - - case GT_CNS_STR: - if (op1->AsStrCon()->gtSconCPX == op2->AsStrCon()->gtSconCPX) - { - return true; - } - break; - - case GT_LCL_VAR: - if (op1->AsLclVarCommon()->GetLclNum() == op2->AsLclVarCommon()->GetLclNum()) - { - return true; - } - break; - - case GT_CLS_VAR: - if (op1->AsClsVar()->gtClsVarHnd == op2->AsClsVar()->gtClsVarHnd) - { - return true; - } - break; - - default: - // we return false for these unhandled 'oper' kinds - break; - } - } - return false; -} - //------------------------------------------------------------------------ // gtGetThisArg: Return this pointer node for the call. // @@ -8757,28 +8662,6 @@ GenTree* Compiler::gtGetThisArg(GenTreeCall* call) // Assert if we used DEBUG_DESTROY_NODE. assert(result->gtOper != GT_COUNT); -#if !FEATURE_FIXED_OUT_ARGS && defined(DEBUG) - // Check that call->fgArgInfo used in gtArgEntryByArgNum was not - // left outdated by assertion propogation updates. - // There is no information about registers of late args for platforms - // with FEATURE_FIXED_OUT_ARGS that is why this debug check is under - // !FEATURE_FIXED_OUT_ARGS. - regNumber thisReg = REG_ARG_0; - regList list = call->regArgList; - int index = 0; - for (GenTreeCall::Use& use : call->LateArgs()) - { - assert(index < call->regArgListCount); - regNumber curArgReg = list[index]; - if (curArgReg == thisReg) - { - assert(result == use.GetNode()); - } - - index++; - } -#endif // !FEATURE_FIXED_OUT_ARGS && defined(DEBUG) - return result; } @@ -10476,12 +10359,6 @@ void Compiler::gtDispNode(GenTree* tree, IndentStack* indentStack, __in __in_z _ --msgLength; break; } - if (tree->gtFlags & GTF_RELOP_QMARK) - { - printf("Q"); - --msgLength; - break; - } goto DASH; case GT_JCMP: @@ -10864,12 +10741,6 @@ void Compiler::gtGetLclVarNameInfo(unsigned lclNum, const char** ilKindOut, cons ilName = "OutArgs"; } #endif // FEATURE_FIXED_OUT_ARGS -#ifdef TARGET_ARM - else if (lclNum == lvaPromotedStructAssemblyScratchVar) - { - ilName = "PromotedStructScratch"; - } -#endif // TARGET_ARM #if !defined(FEATURE_EH_FUNCLETS) else if (lclNum == lvaShadowSPslotsVar) { @@ -12050,9 +11921,6 @@ void Compiler::gtDispTree(GenTree* tree, (call->gtControlExpr == lastChild) ? IIArcBottom : IIArc, "control expr", topOnly); } -#if !FEATURE_FIXED_OUT_ARGS - regList list = call->regArgList; -#endif int lateArgIndex = 0; for (GenTreeCall::Use& use : call->LateArgs()) { @@ -12231,10 +12099,7 @@ void Compiler::gtGetLateArgMsg(GenTreeCall* call, GenTree* argx, int lateArgInde assert(curArgTabEntry); regNumber argReg = curArgTabEntry->GetRegNum(); -#if !FEATURE_FIXED_OUT_ARGS - assert(lateArgIndex < call->regArgListCount); - assert(argReg == call->regArgList[lateArgIndex]); -#else +#if FEATURE_FIXED_OUT_ARGS if (argReg == REG_STK) { sprintf_s(bufp, bufLength, "arg%d in out+%02x%c", curArgTabEntry->argNum, curArgTabEntry->GetByteOffset(), 0); @@ -12987,7 +12852,7 @@ GenTree* Compiler::gtFoldTypeCompare(GenTree* tree) GenTree* compare = gtCreateHandleCompare(oper, op1ClassFromHandle, op2ClassFromHandle, inliningKind); // Drop any now-irrelvant flags - compare->gtFlags |= tree->gtFlags & (GTF_RELOP_JMP_USED | GTF_RELOP_QMARK | GTF_DONT_CSE); + compare->gtFlags |= tree->gtFlags & (GTF_RELOP_JMP_USED | GTF_DONT_CSE); return compare; } @@ -13027,7 +12892,7 @@ GenTree* Compiler::gtFoldTypeCompare(GenTree* tree) GenTree* compare = gtCreateHandleCompare(oper, arg1, arg2, inliningKind); // Drop any now-irrelvant flags - compare->gtFlags |= tree->gtFlags & (GTF_RELOP_JMP_USED | GTF_RELOP_QMARK | GTF_DONT_CSE); + compare->gtFlags |= tree->gtFlags & (GTF_RELOP_JMP_USED | GTF_DONT_CSE); return compare; } @@ -13125,7 +12990,7 @@ GenTree* Compiler::gtFoldTypeCompare(GenTree* tree) GenTree* const compare = gtCreateHandleCompare(oper, objMT, knownMT, typeCheckInliningResult); // Drop any now irrelevant flags - compare->gtFlags |= tree->gtFlags & (GTF_RELOP_JMP_USED | GTF_RELOP_QMARK | GTF_DONT_CSE); + compare->gtFlags |= tree->gtFlags & (GTF_RELOP_JMP_USED | GTF_DONT_CSE); // And we're done return compare; @@ -15921,7 +15786,6 @@ void Compiler::gtExtractSideEffList(GenTree* expr, */ #ifdef DEBUG - void dispNodeList(GenTree* list, bool verbose) { GenTree* last = nullptr; @@ -15955,21 +15819,7 @@ void dispNodeList(GenTree* list, bool verbose) } printf(""); // null string means flush } - -/***************************************************************************** - * Callback to assert that the nodes of a qmark-colon subtree are marked - */ - -/* static */ -Compiler::fgWalkResult Compiler::gtAssertColonCond(GenTree** pTree, fgWalkData* data) -{ - assert(data->pCallbackData == nullptr); - - assert((*pTree)->gtFlags & GTF_COLON_COND); - - return WALK_CONTINUE; -} -#endif // DEBUG +#endif /***************************************************************************** * Callback to mark the nodes of a qmark-colon subtree that are conditionally diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h index 091c2464e69502..99604714926278 100644 --- a/src/coreclr/jit/gentree.h +++ b/src/coreclr/jit/gentree.h @@ -21,7 +21,6 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX #include "vartype.h" // For "var_types" #include "target.h" // For "regNumber" #include "ssaconfig.h" // For "SsaConfig::RESERVED_SSA_NUM" -#include "reglist.h" #include "valuenumtype.h" #include "jitstd.h" #include "jithashtable.h" @@ -527,7 +526,6 @@ enum GenTreeFlags : unsigned int GTF_RELOP_NAN_UN = 0x80000000, // GT_ -- Is branch taken if ops are NaN? GTF_RELOP_JMP_USED = 0x40000000, // GT_ -- result of compare used for jump or ?: - GTF_RELOP_QMARK = 0x20000000, // GT_ -- the node is the condition for ?: GTF_RELOP_ZTT = 0x08000000, // GT_ -- Loop test cloned for converting while-loops into do-while // with explicit "loop test" in the header block. @@ -4244,11 +4242,6 @@ struct GenTreeCall final : public GenTree return UseList(gtCallLateArgs); } -#if !FEATURE_FIXED_OUT_ARGS - int regArgListCount; - regList regArgList; -#endif - #ifdef DEBUG // Used to register callsites with the EE CORINFO_SIG_INFO* callSig; diff --git a/src/coreclr/jit/lclvars.cpp b/src/coreclr/jit/lclvars.cpp index 2d2ae92df4203f..0c865355afe1e8 100644 --- a/src/coreclr/jit/lclvars.cpp +++ b/src/coreclr/jit/lclvars.cpp @@ -56,9 +56,6 @@ void Compiler::lvaInit() lvaOutgoingArgSpaceVar = BAD_VAR_NUM; lvaOutgoingArgSpaceSize = PhasedVar(); #endif // FEATURE_FIXED_OUT_ARGS -#ifdef TARGET_ARM - lvaPromotedStructAssemblyScratchVar = BAD_VAR_NUM; -#endif // TARGET_ARM #ifdef JIT32_GCENCODER lvaLocAllocSPvar = BAD_VAR_NUM; #endif // JIT32_GCENCODER diff --git a/src/coreclr/jit/morph.cpp b/src/coreclr/jit/morph.cpp index 83946626f25d92..8f30f4e3a52b2f 100644 --- a/src/coreclr/jit/morph.cpp +++ b/src/coreclr/jit/morph.cpp @@ -1712,27 +1712,6 @@ void fgArgInfo::SortArgs() assert(begTab == (endTab + 1)); assert(argsRemaining == 0); -#if !FEATURE_FIXED_OUT_ARGS - // Finally build the regArgList - // - callTree->AsCall()->regArgList = NULL; - callTree->AsCall()->regArgListCount = regCount; - - unsigned regInx = 0; - for (curInx = 0; curInx < argCount; curInx++) - { - fgArgTabEntry* curArgTabEntry = argTable[curInx]; - - if (curArgTabEntry->GetRegNum() != REG_STK) - { - // Encode the argument register in the register mask - // - callTree->AsCall()->regArgList[regInx] = curArgTabEntry->GetRegNum(); - regInx++; - } - } -#endif // !FEATURE_FIXED_OUT_ARGS - argsSorted = true; } @@ -11034,7 +11013,6 @@ GenTree* Compiler::fgMorphSmpOp(GenTree* tree, MorphAddrContext* mac) if (op1->OperKind() & GTK_RELOP) { - noway_assert((oper == GT_JTRUE) || (op1->gtFlags & GTF_RELOP_QMARK)); /* Mark the comparison node with GTF_RELOP_JMP_USED so it knows that it does not need to materialize the result as a 0 or 1. */ @@ -12007,12 +11985,6 @@ GenTree* Compiler::fgMorphSmpOp(GenTree* tree, MorphAddrContext* mac) effectiveOp1 = op1->gtEffectiveVal(); - if (effectiveOp1->OperIsConst()) - { - op1 = gtNewOperNode(GT_IND, tree->TypeGet(), op1); - tree->AsOp()->gtOp1 = op1; - } - // If we are storing a small type, we might be able to omit a cast. if (effectiveOp1->OperIs(GT_IND) && varTypeIsSmall(effectiveOp1)) { @@ -13090,15 +13062,6 @@ GenTree* Compiler::fgMorphSmpOp(GenTree* tree, MorphAddrContext* mac) return addr; } - else if (op1->gtOper == GT_CAST) - { - GenTree* casting = op1->AsCast()->CastOp(); - if (casting->gtOper == GT_LCL_VAR || casting->gtOper == GT_CLS_VAR) - { - DEBUG_DESTROY_NODE(op1); - tree->AsOp()->gtOp1 = op1 = casting; - } - } else if ((op1->gtOper == GT_COMMA) && !optValnumCSE_phase) { // Perform the transform ADDR(COMMA(x, ..., z)) == COMMA(x, ..., ADDR(z)). @@ -13509,7 +13472,7 @@ GenTree* Compiler::fgOptimizeEqualityComparisonWithConst(GenTreeOp* cmp) } noway_assert((op1->gtFlags & GTF_RELOP_JMP_USED) == 0); - op1->gtFlags |= cmp->gtFlags & (GTF_RELOP_JMP_USED | GTF_RELOP_QMARK | GTF_DONT_CSE); + op1->gtFlags |= cmp->gtFlags & (GTF_RELOP_JMP_USED | GTF_DONT_CSE); op1->SetVNsFromNode(cmp); DEBUG_DESTROY_NODE(cmp); @@ -16379,9 +16342,6 @@ void Compiler::fgExpandQmarkForCastInstOf(BasicBlock* block, Statement* stmt) cond2Expr = nestedQmark->gtGetOp1(); true2Expr = nestedQmark->gtGetOp2()->AsColon()->ThenNode(); false2Expr = nestedQmark->gtGetOp2()->AsColon()->ElseNode(); - - assert(cond2Expr->gtFlags & GTF_RELOP_QMARK); - cond2Expr->gtFlags &= ~GTF_RELOP_QMARK; } else { @@ -16399,10 +16359,6 @@ void Compiler::fgExpandQmarkForCastInstOf(BasicBlock* block, Statement* stmt) } assert(false2Expr->OperGet() == trueExpr->OperGet()); - // Clear flags as they are now going to be part of JTRUE. - assert(condExpr->gtFlags & GTF_RELOP_QMARK); - condExpr->gtFlags &= ~GTF_RELOP_QMARK; - // Create the chain of blocks. See method header comment. // The order of blocks after this is the following: // block ... asgBlock ... cond1Block ... cond2Block ... helperBlock ... remainderBlock @@ -16573,9 +16529,6 @@ void Compiler::fgExpandQmarkStmt(BasicBlock* block, Statement* stmt) GenTree* trueExpr = qmark->gtGetOp2()->AsColon()->ThenNode(); GenTree* falseExpr = qmark->gtGetOp2()->AsColon()->ElseNode(); - assert(condExpr->gtFlags & GTF_RELOP_QMARK); - condExpr->gtFlags &= ~GTF_RELOP_QMARK; - assert(!varTypeIsFloating(condExpr->TypeGet())); bool hasTrueExpr = (trueExpr->OperGet() != GT_NOP); diff --git a/src/coreclr/jit/reglist.h b/src/coreclr/jit/reglist.h deleted file mode 100644 index c8948b80e1b1ca..00000000000000 --- a/src/coreclr/jit/reglist.h +++ /dev/null @@ -1,17 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -#ifndef REGLIST_H -#define REGLIST_H - -#include "target.h" -#include "tinyarray.h" - -// The "regList" type is a small set of registerse -#ifdef TARGET_X86 -typedef TinyArray regList; -#else -// The regList is unused for all other targets. -#endif // TARGET* - -#endif // REGLIST_H