summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/jit/codegenarmarch.cpp4
-rw-r--r--src/jit/codegenclassic.h26
-rw-r--r--src/jit/codegenlegacy.cpp32
-rw-r--r--src/jit/codegenxarch.cpp8
-rw-r--r--src/jit/compiler.h82
-rw-r--r--src/jit/earlyprop.cpp2
-rw-r--r--src/jit/flowgraph.cpp6
-rw-r--r--src/jit/gentree.cpp50
-rw-r--r--src/jit/gentree.h5
-rw-r--r--src/jit/lower.cpp10
-rw-r--r--src/jit/lower.h2
-rw-r--r--src/jit/lsraarmarch.cpp6
-rw-r--r--src/jit/lsraxarch.cpp2
-rw-r--r--src/jit/morph.cpp189
-rw-r--r--src/jit/optcse.cpp10
-rw-r--r--src/jit/regalloc.cpp2
16 files changed, 214 insertions, 222 deletions
diff --git a/src/jit/codegenarmarch.cpp b/src/jit/codegenarmarch.cpp
index deab3b67b9..9ed3617f30 100644
--- a/src/jit/codegenarmarch.cpp
+++ b/src/jit/codegenarmarch.cpp
@@ -556,7 +556,7 @@ void CodeGen::genPutArgStk(GenTreePutArgStk* treeNode)
unsigned argOffsetOut = treeNode->gtSlotNum * TARGET_POINTER_SIZE;
#ifdef DEBUG
- fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(treeNode->gtCall, treeNode);
+ fgArgTabEntry* curArgTabEntry = compiler->gtArgEntryByNode(treeNode->gtCall, treeNode);
assert(curArgTabEntry);
assert(argOffsetOut == (curArgTabEntry->slotNum * TARGET_POINTER_SIZE));
#endif // DEBUG
@@ -2194,7 +2194,7 @@ void CodeGen::genCallInstruction(GenTreeCall* call)
GenTreePtr argNode = list->Current();
- fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, argNode);
+ fgArgTabEntry* curArgTabEntry = compiler->gtArgEntryByNode(call, argNode);
assert(curArgTabEntry);
// GT_RELOAD/GT_COPY use the child node
diff --git a/src/jit/codegenclassic.h b/src/jit/codegenclassic.h
index 5794975b6c..babc6a472f 100644
--- a/src/jit/codegenclassic.h
+++ b/src/jit/codegenclassic.h
@@ -331,18 +331,18 @@ size_t genPushArgList(GenTreeCall* call);
// allocates a register, uses it, and sets "*pRegTmp" to the allocated register.
//
// Returns "true" iff it filled two slots with an 8-byte value.
-bool genFillSlotFromPromotedStruct(GenTreePtr arg,
- fgArgTabEntryPtr curArgTabEntry,
- LclVarDsc* promotedStructLocalVarDesc,
- emitAttr fieldSize,
- unsigned* pNextPromotedStructFieldVar, // IN/OUT
- unsigned* pBytesOfNextSlotOfCurPromotedStruct, // IN/OUT
- regNumber* pCurRegNum, // IN/OUT
- int argOffset,
- int fieldOffsetOfFirstStackSlot,
- int argOffsetOfFirstStackSlot,
- regMaskTP* deadFieldVarRegs, // OUT
- regNumber* pRegTmp); // IN/OUT
+bool genFillSlotFromPromotedStruct(GenTreePtr arg,
+ fgArgTabEntry* curArgTabEntry,
+ LclVarDsc* promotedStructLocalVarDesc,
+ emitAttr fieldSize,
+ unsigned* pNextPromotedStructFieldVar, // IN/OUT
+ unsigned* pBytesOfNextSlotOfCurPromotedStruct, // IN/OUT
+ regNumber* pCurRegNum, // IN/OUT
+ int argOffset,
+ int fieldOffsetOfFirstStackSlot,
+ int argOffsetOfFirstStackSlot,
+ regMaskTP* deadFieldVarRegs, // OUT
+ regNumber* pRegTmp); // IN/OUT
#endif // _TARGET_ARM_
// Requires that "curr" is a cpblk. If the RHS is a promoted struct local,
@@ -354,7 +354,7 @@ regMaskTP genFindDeadFieldRegs(GenTreePtr cpBlk);
void SetupLateArgs(GenTreeCall* call);
#ifdef _TARGET_ARM_
-void PushMkRefAnyArg(GenTreePtr mkRefAnyTree, fgArgTabEntryPtr curArgTabEntry, regMaskTP regNeedMask);
+void PushMkRefAnyArg(GenTreePtr mkRefAnyTree, fgArgTabEntry* curArgTabEntry, regMaskTP regNeedMask);
#endif // _TARGET_ARM_
regMaskTP genLoadIndirectCallTarget(GenTreeCall* call);
diff --git a/src/jit/codegenlegacy.cpp b/src/jit/codegenlegacy.cpp
index effd4e6948..945f7bd812 100644
--- a/src/jit/codegenlegacy.cpp
+++ b/src/jit/codegenlegacy.cpp
@@ -16431,7 +16431,7 @@ size_t CodeGen::genPushArgList(GenTreeCall* call)
assert(!curr->IsArgPlaceHolderNode()); // No place holders nodes are in the late args
- fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, curr);
+ fgArgTabEntry* curArgTabEntry = compiler->gtArgEntryByNode(call, curr);
assert(curArgTabEntry);
regNumber regNum = curArgTabEntry->regNum;
@@ -16541,7 +16541,7 @@ size_t CodeGen::genPushArgList(GenTreeCall* call)
/* Get hold of the next argument value */
curr = args->Current();
- fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, curr);
+ fgArgTabEntry* curArgTabEntry = compiler->gtArgEntryByNode(call, curr);
assert(curArgTabEntry);
regNumber regNum = curArgTabEntry->regNum;
int argOffset = curArgTabEntry->slotNum * TARGET_POINTER_SIZE;
@@ -16958,18 +16958,18 @@ size_t CodeGen::genPushArgList(GenTreeCall* call)
}
#ifdef _TARGET_ARM_
-bool CodeGen::genFillSlotFromPromotedStruct(GenTreePtr arg,
- fgArgTabEntryPtr curArgTabEntry,
- LclVarDsc* promotedStructLocalVarDesc,
- emitAttr fieldSize,
- unsigned* pNextPromotedStructFieldVar,
- unsigned* pBytesOfNextSlotOfCurPromotedStruct,
- regNumber* pCurRegNum,
- int argOffset,
- int fieldOffsetOfFirstStackSlot,
- int argOffsetOfFirstStackSlot,
- regMaskTP* deadFieldVarRegs,
- regNumber* pRegTmp)
+bool CodeGen::genFillSlotFromPromotedStruct(GenTreePtr arg,
+ fgArgTabEntry* curArgTabEntry,
+ LclVarDsc* promotedStructLocalVarDesc,
+ emitAttr fieldSize,
+ unsigned* pNextPromotedStructFieldVar,
+ unsigned* pBytesOfNextSlotOfCurPromotedStruct,
+ regNumber* pCurRegNum,
+ int argOffset,
+ int fieldOffsetOfFirstStackSlot,
+ int argOffsetOfFirstStackSlot,
+ regMaskTP* deadFieldVarRegs,
+ regNumber* pRegTmp)
{
unsigned nextPromotedStructFieldVar = *pNextPromotedStructFieldVar;
unsigned limitPromotedStructFieldVar =
@@ -17497,7 +17497,7 @@ void CodeGen::SetupLateArgs(GenTreeCall* call)
curr = lateArgs->Current();
assert(curr);
- fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, curr);
+ fgArgTabEntry* curArgTabEntry = compiler->gtArgEntryByNode(call, curr);
assert(curArgTabEntry);
regNumber regNum = curArgTabEntry->regNum;
unsigned argOffset = curArgTabEntry->slotNum * TARGET_POINTER_SIZE;
@@ -18084,7 +18084,7 @@ void CodeGen::SetupLateArgs(GenTreeCall* call)
// been pushed onto the stack, but *no* registers have been marked
// as 'in-use', that is the responsibility of the caller.
//
-void CodeGen::PushMkRefAnyArg(GenTreePtr mkRefAnyTree, fgArgTabEntryPtr curArgTabEntry, regMaskTP regNeedMask)
+void CodeGen::PushMkRefAnyArg(GenTreePtr mkRefAnyTree, fgArgTabEntry* curArgTabEntry, regMaskTP regNeedMask)
{
regNumber regNum = curArgTabEntry->regNum;
regNumber regNum2;
diff --git a/src/jit/codegenxarch.cpp b/src/jit/codegenxarch.cpp
index 2f838ce17d..7ff2ca76bc 100644
--- a/src/jit/codegenxarch.cpp
+++ b/src/jit/codegenxarch.cpp
@@ -5101,7 +5101,7 @@ void CodeGen::genCallInstruction(GenTreeCall* call)
GenTreePtr argNode = list->Current();
- fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, argNode->gtSkipReloadOrCopy());
+ fgArgTabEntry* curArgTabEntry = compiler->gtArgEntryByNode(call, argNode->gtSkipReloadOrCopy());
assert(curArgTabEntry);
if (curArgTabEntry->regNum == REG_STK)
@@ -5186,7 +5186,7 @@ void CodeGen::genCallInstruction(GenTreeCall* call)
unsigned size = arg->AsPutArgStk()->getArgSize();
stackArgBytes += size;
#ifdef DEBUG
- fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, arg);
+ fgArgTabEntry* curArgTabEntry = compiler->gtArgEntryByNode(call, arg);
assert(curArgTabEntry);
assert(size == (curArgTabEntry->numSlots * TARGET_POINTER_SIZE));
#ifdef FEATURE_PUT_STRUCT_ARG_STK
@@ -8051,10 +8051,10 @@ void CodeGen::genPutArgStk(GenTreePutArgStk* putArgStk)
// Get argument offset on stack.
// Here we cross check that argument offset hasn't changed from lowering to codegen since
// we are storing arg slot number in GT_PUTARG_STK node in lowering phase.
- int argOffset = putArgStk->getArgOffset();
+ int argOffset = putArgStk->getArgOffset();
#ifdef DEBUG
- fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(putArgStk->gtCall, putArgStk);
+ fgArgTabEntry* curArgTabEntry = compiler->gtArgEntryByNode(putArgStk->gtCall, putArgStk);
assert(curArgTabEntry);
assert(argOffset == (int)curArgTabEntry->slotNum * TARGET_POINTER_SIZE);
#endif
diff --git a/src/jit/compiler.h b/src/jit/compiler.h
index c59a397297..a97530c6c1 100644
--- a/src/jit/compiler.h
+++ b/src/jit/compiler.h
@@ -1293,7 +1293,6 @@ struct fgArgTabEntry
void Dump();
#endif
};
-typedef struct fgArgTabEntry* fgArgTabEntryPtr;
//-------------------------------------------------------------------------
//
@@ -1322,44 +1321,43 @@ class fgArgInfo
unsigned outArgSize; // Size of the out arg area for the call, will be at least MIN_ARG_AREA_FOR_CALL
#endif
- unsigned argTableSize; // size of argTable array (equal to the argCount when done with fgMorphArgs)
- bool hasRegArgs; // true if we have one or more register arguments
- bool hasStackArgs; // true if we have one or more stack arguments
- bool argsComplete; // marker for state
- bool argsSorted; // marker for state
- fgArgTabEntryPtr* argTable; // variable sized array of per argument descrption: (i.e. argTable[argTableSize])
+ unsigned argTableSize; // size of argTable array (equal to the argCount when done with fgMorphArgs)
+ bool hasRegArgs; // true if we have one or more register arguments
+ bool hasStackArgs; // true if we have one or more stack arguments
+ bool argsComplete; // marker for state
+ bool argsSorted; // marker for state
+ fgArgTabEntry** argTable; // variable sized array of per argument descrption: (i.e. argTable[argTableSize])
private:
- void AddArg(fgArgTabEntryPtr curArgTabEntry);
+ void AddArg(fgArgTabEntry* curArgTabEntry);
public:
fgArgInfo(Compiler* comp, GenTreeCall* call, unsigned argCount);
fgArgInfo(GenTreeCall* newCall, GenTreeCall* oldCall);
- fgArgTabEntryPtr AddRegArg(
+ fgArgTabEntry* AddRegArg(
unsigned argNum, GenTreePtr node, GenTreePtr parent, regNumber regNum, unsigned numRegs, unsigned alignment);
#ifdef FEATURE_UNIX_AMD64_STRUCT_PASSING
- fgArgTabEntryPtr AddRegArg(
- unsigned argNum,
- GenTreePtr node,
- GenTreePtr parent,
- regNumber regNum,
- unsigned numRegs,
- unsigned alignment,
- const bool isStruct,
- const regNumber otherRegNum = REG_NA,
- const SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* const structDescPtr = nullptr);
+ fgArgTabEntry* AddRegArg(unsigned argNum,
+ GenTreePtr node,
+ GenTreePtr parent,
+ regNumber regNum,
+ unsigned numRegs,
+ unsigned alignment,
+ const bool isStruct,
+ const regNumber otherRegNum = REG_NA,
+ const SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* const structDescPtr = nullptr);
#endif // FEATURE_UNIX_AMD64_STRUCT_PASSING
- fgArgTabEntryPtr AddStkArg(unsigned argNum,
- GenTreePtr node,
- GenTreePtr parent,
- unsigned numSlots,
- unsigned alignment FEATURE_UNIX_AMD64_STRUCT_PASSING_ONLY_ARG(const bool isStruct));
+ fgArgTabEntry* AddStkArg(unsigned argNum,
+ GenTreePtr node,
+ GenTreePtr parent,
+ unsigned numSlots,
+ unsigned alignment FEATURE_UNIX_AMD64_STRUCT_PASSING_ONLY_ARG(const bool isStruct));
- void RemorphReset();
- fgArgTabEntryPtr RemorphRegArg(
+ void RemorphReset();
+ fgArgTabEntry* RemorphRegArg(
unsigned argNum, GenTreePtr node, GenTreePtr parent, regNumber regNum, unsigned numRegs, unsigned alignment);
void RemorphStkArg(unsigned argNum, GenTreePtr node, GenTreePtr parent, unsigned numSlots, unsigned alignment);
@@ -1381,7 +1379,7 @@ public:
{
return argCount;
}
- fgArgTabEntryPtr* ArgTable()
+ fgArgTabEntry** ArgTable()
{
return argTable;
}
@@ -2109,10 +2107,10 @@ public:
GenTreeArgList* gtNewArgList(GenTreePtr op1, GenTreePtr op2, GenTreePtr op3);
GenTreeArgList* gtNewArgList(GenTreePtr op1, GenTreePtr op2, GenTreePtr op3, GenTreePtr op4);
- static fgArgTabEntryPtr gtArgEntryByArgNum(GenTreeCall* call, unsigned argNum);
- static fgArgTabEntryPtr gtArgEntryByNode(GenTreeCall* call, GenTreePtr node);
- fgArgTabEntryPtr gtArgEntryByLateArgIndex(GenTreeCall* call, unsigned lateArgInx);
- bool gtArgIsThisPtr(fgArgTabEntryPtr argEntry);
+ static fgArgTabEntry* gtArgEntryByArgNum(GenTreeCall* call, unsigned argNum);
+ static fgArgTabEntry* gtArgEntryByNode(GenTreeCall* call, GenTreePtr node);
+ fgArgTabEntry* gtArgEntryByLateArgIndex(GenTreeCall* call, unsigned lateArgInx);
+ bool gtArgIsThisPtr(fgArgTabEntry* argEntry);
GenTreePtr gtNewAssignNode(GenTreePtr dst, GenTreePtr src);
@@ -4923,12 +4921,12 @@ private:
bool fgCheckStmtAfterTailCall();
void fgMorphTailCall(GenTreeCall* call);
void fgMorphRecursiveFastTailCallIntoLoop(BasicBlock* block, GenTreeCall* recursiveTailCall);
- GenTreePtr fgAssignRecursiveCallArgToCallerParam(GenTreePtr arg,
- fgArgTabEntryPtr argTabEntry,
- BasicBlock* block,
- IL_OFFSETX callILOffset,
- GenTreePtr tmpAssignmentInsertionPoint,
- GenTreePtr paramAssignmentInsertionPoint);
+ GenTreePtr fgAssignRecursiveCallArgToCallerParam(GenTreePtr arg,
+ fgArgTabEntry* argTabEntry,
+ BasicBlock* block,
+ IL_OFFSETX callILOffset,
+ GenTreePtr tmpAssignmentInsertionPoint,
+ GenTreePtr paramAssignmentInsertionPoint);
static int fgEstimateCallStackSize(GenTreeCall* call);
GenTreePtr fgMorphCall(GenTreeCall* call);
void fgMorphCallInline(GenTreeCall* call, InlineResult* result);
@@ -5667,8 +5665,6 @@ protected:
GenTreePtr tlTree;
};
- typedef struct treeLst* treeLstPtr;
-
struct treeStmtLst
{
treeStmtLst* tslNext;
@@ -5677,8 +5673,6 @@ protected:
BasicBlock* tslBlock; // block containing the statement
};
- typedef struct treeStmtLst* treeStmtLstPtr;
-
// The following logic keeps track of expressions via a simple hash table.
struct CSEdsc
@@ -5700,8 +5694,8 @@ protected:
GenTreePtr csdStmt; // stmt containing the 1st occurance
BasicBlock* csdBlock; // block containing the 1st occurance
- treeStmtLstPtr csdTreeList; // list of matching tree nodes: head
- treeStmtLstPtr csdTreeLast; // list of matching tree nodes: tail
+ treeStmtLst* csdTreeList; // list of matching tree nodes: head
+ treeStmtLst* csdTreeLast; // list of matching tree nodes: tail
ValueNum defConservativeVN; // if all def occurrences share the same conservative value
// number, this will reflect it; otherwise, NoVN.
@@ -9687,7 +9681,7 @@ public:
#endif // defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
void fgMorphMultiregStructArgs(GenTreeCall* call);
- GenTreePtr fgMorphMultiregStructArg(GenTreePtr arg, fgArgTabEntryPtr fgEntryPtr);
+ GenTreePtr fgMorphMultiregStructArg(GenTreePtr arg, fgArgTabEntry* fgEntryPtr);
bool killGCRefs(GenTreePtr tree);
diff --git a/src/jit/earlyprop.cpp b/src/jit/earlyprop.cpp
index b0cb26b973..8b3c654401 100644
--- a/src/jit/earlyprop.cpp
+++ b/src/jit/earlyprop.cpp
@@ -123,7 +123,7 @@ GenTreePtr Compiler::getObjectHandleNodeFromAllocation(GenTreePtr tree)
call->gtCallMethHnd == eeFindHelper(CORINFO_HELP_NEWARR_1_ALIGN8))
{
// This is an object allocation site. Return the runtime type handle node.
- fgArgTabEntryPtr argTabEntry = gtArgEntryByArgNum(call, 0);
+ fgArgTabEntry* argTabEntry = gtArgEntryByArgNum(call, 0);
return argTabEntry->node;
}
}
diff --git a/src/jit/flowgraph.cpp b/src/jit/flowgraph.cpp
index d3e6c8c339..4a5e03279a 100644
--- a/src/jit/flowgraph.cpp
+++ b/src/jit/flowgraph.cpp
@@ -3316,8 +3316,7 @@ Compiler::SwitchUniqueSuccSet Compiler::GetDescriptorForSwitch(BasicBlock* switc
// Now we have a set of unique successors.
unsigned numNonDups = BitVecOps::Count(&blockVecTraits, uniqueSuccBlocks);
- typedef BasicBlock* BasicBlockPtr;
- BasicBlockPtr* nonDups = new (getAllocator()) BasicBlockPtr[numNonDups];
+ BasicBlock** nonDups = new (getAllocator()) BasicBlock*[numNonDups];
unsigned nonDupInd = 0;
// At this point, all unique targets are in "uniqueSuccBlocks". As we encounter each,
@@ -3385,8 +3384,7 @@ void Compiler::SwitchUniqueSuccSet::UpdateTarget(CompAllocator* alloc,
else if (fromStillPresent && !toAlreadyPresent)
{
// reallocate to add an entry
- typedef BasicBlock* BasicBlockPtr;
- BasicBlockPtr* newNonDups = new (alloc) BasicBlockPtr[numDistinctSuccs + 1];
+ BasicBlock** newNonDups = new (alloc) BasicBlock*[numDistinctSuccs + 1];
memcpy(newNonDups, nonDuplicates, numDistinctSuccs * sizeof(BasicBlock*));
newNonDups[numDistinctSuccs] = to;
numDistinctSuccs++;
diff --git a/src/jit/gentree.cpp b/src/jit/gentree.cpp
index 08f84515a7..6321b5d871 100644
--- a/src/jit/gentree.cpp
+++ b/src/jit/gentree.cpp
@@ -1160,7 +1160,7 @@ void GenTreeCall::ReplaceCallOperand(GenTree** useEdge, GenTree* replacement)
{
assert((replacement->gtFlags & GTF_LATE_ARG) == 0);
- fgArgTabEntryPtr fp = Compiler::gtArgEntryByNode(this, originalOperand);
+ fgArgTabEntry* fp = Compiler::gtArgEntryByNode(this, originalOperand);
assert(fp->node == originalOperand);
fp->node = replacement;
}
@@ -6814,14 +6814,14 @@ GenTreeArgList* Compiler::gtNewArgList(GenTreePtr arg1, GenTreePtr arg2, GenTree
* that has the matching argNum and return the fgArgTableEntryPtr
*/
-fgArgTabEntryPtr Compiler::gtArgEntryByArgNum(GenTreeCall* call, unsigned argNum)
+fgArgTabEntry* Compiler::gtArgEntryByArgNum(GenTreeCall* call, unsigned argNum)
{
- fgArgInfoPtr argInfo = call->fgArgInfo;
+ fgArgInfo* argInfo = call->fgArgInfo;
noway_assert(argInfo != nullptr);
- unsigned argCount = argInfo->ArgCount();
- fgArgTabEntryPtr* argTable = argInfo->ArgTable();
- fgArgTabEntryPtr curArgTabEntry = nullptr;
+ unsigned argCount = argInfo->ArgCount();
+ fgArgTabEntry** argTable = argInfo->ArgTable();
+ fgArgTabEntry* curArgTabEntry = nullptr;
for (unsigned i = 0; i < argCount; i++)
{
@@ -6841,14 +6841,14 @@ fgArgTabEntryPtr Compiler::gtArgEntryByArgNum(GenTreeCall* call, unsigned argNum
* that has the matching node and return the fgArgTableEntryPtr
*/
-fgArgTabEntryPtr Compiler::gtArgEntryByNode(GenTreeCall* call, GenTreePtr node)
+fgArgTabEntry* Compiler::gtArgEntryByNode(GenTreeCall* call, GenTreePtr node)
{
- fgArgInfoPtr argInfo = call->fgArgInfo;
+ fgArgInfo* argInfo = call->fgArgInfo;
noway_assert(argInfo != nullptr);
- unsigned argCount = argInfo->ArgCount();
- fgArgTabEntryPtr* argTable = argInfo->ArgTable();
- fgArgTabEntryPtr curArgTabEntry = nullptr;
+ unsigned argCount = argInfo->ArgCount();
+ fgArgTabEntry** argTable = argInfo->ArgTable();
+ fgArgTabEntry* curArgTabEntry = nullptr;
for (unsigned i = 0; i < argCount; i++)
{
@@ -6883,14 +6883,14 @@ fgArgTabEntryPtr Compiler::gtArgEntryByNode(GenTreeCall* call, GenTreePtr node)
* Find and return the entry with the given "lateArgInx". Requires that one is found
* (asserts this).
*/
-fgArgTabEntryPtr Compiler::gtArgEntryByLateArgIndex(GenTreeCall* call, unsigned lateArgInx)
+fgArgTabEntry* Compiler::gtArgEntryByLateArgIndex(GenTreeCall* call, unsigned lateArgInx)
{
- fgArgInfoPtr argInfo = call->fgArgInfo;
+ fgArgInfo* argInfo = call->fgArgInfo;
noway_assert(argInfo != nullptr);
- unsigned argCount = argInfo->ArgCount();
- fgArgTabEntryPtr* argTable = argInfo->ArgTable();
- fgArgTabEntryPtr curArgTabEntry = nullptr;
+ unsigned argCount = argInfo->ArgCount();
+ fgArgTabEntry** argTable = argInfo->ArgTable();
+ fgArgTabEntry* curArgTabEntry = nullptr;
for (unsigned i = 0; i < argCount; i++)
{
@@ -6906,9 +6906,9 @@ fgArgTabEntryPtr Compiler::gtArgEntryByLateArgIndex(GenTreeCall* call, unsigned
/*****************************************************************************
*
- * Given an fgArgTabEntryPtr, return true if it is the 'this' pointer argument.
+ * Given an fgArgTabEntry*, return true if it is the 'this' pointer argument.
*/
-bool Compiler::gtArgIsThisPtr(fgArgTabEntryPtr argEntry)
+bool Compiler::gtArgIsThisPtr(fgArgTabEntry* argEntry)
{
return (argEntry->parent == nullptr);
}
@@ -8602,10 +8602,10 @@ GenTreePtr Compiler::gtGetThisArg(GenTreeCall* call)
if (call->gtCallLateArgs)
{
- regNumber thisReg = REG_ARG_0;
- unsigned argNum = 0;
- fgArgTabEntryPtr thisArgTabEntry = gtArgEntryByArgNum(call, argNum);
- GenTreePtr result = thisArgTabEntry->node;
+ regNumber thisReg = REG_ARG_0;
+ unsigned argNum = 0;
+ fgArgTabEntry* thisArgTabEntry = gtArgEntryByArgNum(call, argNum);
+ GenTreePtr result = thisArgTabEntry->node;
#if !FEATURE_FIXED_OUT_ARGS
GenTreePtr lateArgs = call->gtCallLateArgs;
@@ -11889,7 +11889,7 @@ void Compiler::gtGetArgMsg(
{
if (call->gtCallLateArgs != nullptr)
{
- fgArgTabEntryPtr curArgTabEntry = gtArgEntryByArgNum(call, argNum);
+ fgArgTabEntry* curArgTabEntry = gtArgEntryByArgNum(call, argNum);
assert(curArgTabEntry);
if (arg->gtFlags & GTF_LATE_ARG)
@@ -12007,7 +12007,7 @@ void Compiler::gtGetLateArgMsg(
{
assert(!argx->IsArgPlaceHolderNode()); // No place holders nodes are in gtCallLateArgs;
- fgArgTabEntryPtr curArgTabEntry = gtArgEntryByLateArgIndex(call, lateArgIndex);
+ fgArgTabEntry* curArgTabEntry = gtArgEntryByLateArgIndex(call, lateArgIndex);
assert(curArgTabEntry);
regNumber argReg = curArgTabEntry->regNum;
@@ -12301,7 +12301,7 @@ void Compiler::gtDispLIRNode(GenTree* node, const char* prefixMsg /* = nullptr *
}
else
{
- fgArgTabEntryPtr curArgTabEntry = gtArgEntryByNode(call, operand);
+ fgArgTabEntry* curArgTabEntry = gtArgEntryByNode(call, operand);
assert(curArgTabEntry);
if (operand->OperGet() == GT_LIST)
diff --git a/src/jit/gentree.h b/src/jit/gentree.h
index fb4d0e8272..b7653217df 100644
--- a/src/jit/gentree.h
+++ b/src/jit/gentree.h
@@ -3178,7 +3178,6 @@ struct GenTreeColon : public GenTreeOp
};
// gtCall -- method call (GT_CALL)
-typedef class fgArgInfo* fgArgInfoPtr;
enum class InlineObservation;
// Return type descriptor of a GT_CALL node.
@@ -3324,6 +3323,8 @@ public:
regMaskTP GetABIReturnRegs();
};
+class fgArgInfo;
+
struct GenTreeCall final : public GenTree
{
GenTreePtr gtCallObjp; // The instance argument ('this' pointer)
@@ -3331,7 +3332,7 @@ struct GenTreeCall final : public GenTree
GenTreeArgList* gtCallLateArgs; // On x86: The register arguments in an optimal order
// On ARM/x64: - also includes any outgoing arg space arguments
// - that were evaluated into a temp LclVar
- fgArgInfoPtr fgArgInfo;
+ fgArgInfo* fgArgInfo;
#if !FEATURE_FIXED_OUT_ARGS
int regArgListCount;
diff --git a/src/jit/lower.cpp b/src/jit/lower.cpp
index f2118bf5a9..b007fd7745 100644
--- a/src/jit/lower.cpp
+++ b/src/jit/lower.cpp
@@ -986,7 +986,7 @@ void Lowering::ReplaceArgWithPutArgOrBitcast(GenTree** argSlot, GenTree* putArgO
// layout object, so the codegen of the GT_PUTARG_STK could use this for optimizing copying to the stack by value.
// (using block copy primitives for non GC pointers and a single TARGET_POINTER_SIZE copy with recording GC info.)
//
-GenTreePtr Lowering::NewPutArg(GenTreeCall* call, GenTreePtr arg, fgArgTabEntryPtr info, var_types type)
+GenTreePtr Lowering::NewPutArg(GenTreeCall* call, GenTreePtr arg, fgArgTabEntry* info, var_types type)
{
assert(call != nullptr);
assert(arg != nullptr);
@@ -1393,7 +1393,7 @@ void Lowering::LowerArg(GenTreeCall* call, GenTreePtr* ppArg)
return;
}
- fgArgTabEntryPtr info = comp->gtArgEntryByNode(call, arg);
+ fgArgTabEntry* info = comp->gtArgEntryByNode(call, arg);
assert(info->node == arg);
var_types type = arg->TypeGet();
@@ -2109,7 +2109,7 @@ void Lowering::LowerFastTailCall(GenTreeCall* call)
// stack slots required for both Caller and Callee for passing params
// and allow fast tail call only if stack slots required by Caller >=
// Callee.
- fgArgTabEntryPtr argTabEntry = comp->gtArgEntryByNode(call, putArgStkNode);
+ fgArgTabEntry* argTabEntry = comp->gtArgEntryByNode(call, putArgStkNode);
assert(argTabEntry);
unsigned callerArgNum = argTabEntry->argNum - calleeNonStandardArgCount;
noway_assert(callerArgNum < comp->info.compArgsCount);
@@ -3224,8 +3224,8 @@ GenTree* Lowering::LowerDelegateInvoke(GenTreeCall* call)
const unsigned argNum = 2;
#endif // !_TARGET_X86_
- fgArgTabEntryPtr thisArgTabEntry = comp->gtArgEntryByArgNum(call, argNum);
- thisArgNode = thisArgTabEntry->node;
+ fgArgTabEntry* thisArgTabEntry = comp->gtArgEntryByArgNum(call, argNum);
+ thisArgNode = thisArgTabEntry->node;
}
else
{
diff --git a/src/jit/lower.h b/src/jit/lower.h
index 75cccc4b85..74e71dfab8 100644
--- a/src/jit/lower.h
+++ b/src/jit/lower.h
@@ -159,7 +159,7 @@ private:
GenTree* LowerVirtualStubCall(GenTreeCall* call);
void LowerArgsForCall(GenTreeCall* call);
void ReplaceArgWithPutArgOrBitcast(GenTreePtr* ppChild, GenTreePtr newNode);
- GenTree* NewPutArg(GenTreeCall* call, GenTreePtr arg, fgArgTabEntryPtr info, var_types type);
+ GenTree* NewPutArg(GenTreeCall* call, GenTreePtr arg, fgArgTabEntry* info, var_types type);
void LowerArg(GenTreeCall* call, GenTreePtr* ppTree);
#ifdef _TARGET_ARMARCH_
GenTree* LowerFloatArg(GenTree** pArg, fgArgTabEntry* info);
diff --git a/src/jit/lsraarmarch.cpp b/src/jit/lsraarmarch.cpp
index 17b1958a24..4de53df012 100644
--- a/src/jit/lsraarmarch.cpp
+++ b/src/jit/lsraarmarch.cpp
@@ -480,8 +480,8 @@ void LinearScan::TreeNodeInfoInitCall(GenTreeCall* call, TreeNodeInfo* info)
#ifdef DEBUG
// During TreeNodeInfoInit, we only use the ArgTabEntry for validation,
// as getting it is rather expensive.
- fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, argNode);
- regNumber argReg = curArgTabEntry->regNum;
+ fgArgTabEntry* curArgTabEntry = compiler->gtArgEntryByNode(call, argNode);
+ regNumber argReg = curArgTabEntry->regNum;
assert(curArgTabEntry);
#endif
@@ -587,7 +587,7 @@ void LinearScan::TreeNodeInfoInitCall(GenTreeCall* call, TreeNodeInfo* info)
if (!(args->gtFlags & GTF_LATE_ARG))
{
#ifdef DEBUG
- fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, arg);
+ fgArgTabEntry* curArgTabEntry = compiler->gtArgEntryByNode(call, arg);
assert(curArgTabEntry);
#endif
#ifdef _TARGET_ARM_
diff --git a/src/jit/lsraxarch.cpp b/src/jit/lsraxarch.cpp
index fc28f01c78..f8dadf2336 100644
--- a/src/jit/lsraxarch.cpp
+++ b/src/jit/lsraxarch.cpp
@@ -1295,7 +1295,7 @@ void LinearScan::TreeNodeInfoInitCall(GenTreeCall* call, TreeNodeInfo* info)
#ifdef DEBUG
// In DEBUG only, check validity with respect to the arg table entry.
- fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, argNode);
+ fgArgTabEntry* curArgTabEntry = compiler->gtArgEntryByNode(call, argNode);
assert(curArgTabEntry);
if (curArgTabEntry->regNum == REG_STK)
diff --git a/src/jit/morph.cpp b/src/jit/morph.cpp
index e07e037bf1..b378ff5129 100644
--- a/src/jit/morph.cpp
+++ b/src/jit/morph.cpp
@@ -982,7 +982,7 @@ fgArgInfo::fgArgInfo(Compiler* comp, GenTreeCall* call, unsigned numArgs)
}
else
{
- argTable = new (compiler, CMK_fgArgInfoPtrArr) fgArgTabEntryPtr[argTableSize];
+ argTable = new (compiler, CMK_fgArgInfoPtrArr) fgArgTabEntry*[argTableSize];
}
}
@@ -999,7 +999,7 @@ fgArgInfo::fgArgInfo(Compiler* comp, GenTreeCall* call, unsigned numArgs)
*/
fgArgInfo::fgArgInfo(GenTreeCall* newCall, GenTreeCall* oldCall)
{
- fgArgInfoPtr oldArgInfo = oldCall->gtCall.fgArgInfo;
+ fgArgInfo* oldArgInfo = oldCall->gtCall.fgArgInfo;
compiler = oldArgInfo->compiler;
callTree = newCall;
@@ -1019,7 +1019,7 @@ fgArgInfo::fgArgInfo(GenTreeCall* newCall, GenTreeCall* oldCall)
argTable = nullptr;
if (argTableSize > 0)
{
- argTable = new (compiler, CMK_fgArgInfoPtrArr) fgArgTabEntryPtr[argTableSize];
+ argTable = new (compiler, CMK_fgArgInfoPtrArr) fgArgTabEntry*[argTableSize];
for (unsigned inx = 0; inx < argTableSize; inx++)
{
argTable[inx] = nullptr;
@@ -1051,12 +1051,12 @@ fgArgInfo::fgArgInfo(GenTreeCall* newCall, GenTreeCall* oldCall)
oldArgs = &oldArgObjp;
}
- GenTreePtr newCurr;
- GenTreePtr oldCurr;
- GenTreeArgList* newParent = nullptr;
- GenTreeArgList* oldParent = nullptr;
- fgArgTabEntryPtr* oldArgTable = oldArgInfo->argTable;
- bool scanRegArgs = false;
+ GenTreePtr newCurr;
+ GenTreePtr oldCurr;
+ GenTreeArgList* newParent = nullptr;
+ GenTreeArgList* oldParent = nullptr;
+ fgArgTabEntry** oldArgTable = oldArgInfo->argTable;
+ bool scanRegArgs = false;
while (newArgs)
{
@@ -1076,8 +1076,8 @@ fgArgInfo::fgArgInfo(GenTreeCall* newCall, GenTreeCall* oldCall)
newArgs = newArgs->Rest();
oldArgs = oldArgs->Rest();
- fgArgTabEntryPtr oldArgTabEntry = nullptr;
- fgArgTabEntryPtr newArgTabEntry = nullptr;
+ fgArgTabEntry* oldArgTabEntry = nullptr;
+ fgArgTabEntry* newArgTabEntry = nullptr;
for (unsigned inx = 0; inx < argTableSize; inx++)
{
@@ -1148,8 +1148,8 @@ fgArgInfo::fgArgInfo(GenTreeCall* newCall, GenTreeCall* oldCall)
oldCurr = oldArgs->Current();
oldArgs = oldArgs->Rest();
- fgArgTabEntryPtr oldArgTabEntry = nullptr;
- fgArgTabEntryPtr newArgTabEntry = nullptr;
+ fgArgTabEntry* oldArgTabEntry = nullptr;
+ fgArgTabEntry* newArgTabEntry = nullptr;
for (unsigned inx = 0; inx < argTableSize; inx++)
{
@@ -1181,17 +1181,17 @@ fgArgInfo::fgArgInfo(GenTreeCall* newCall, GenTreeCall* oldCall)
argsSorted = true;
}
-void fgArgInfo::AddArg(fgArgTabEntryPtr curArgTabEntry)
+void fgArgInfo::AddArg(fgArgTabEntry* curArgTabEntry)
{
assert(argCount < argTableSize);
argTable[argCount] = curArgTabEntry;
argCount++;
}
-fgArgTabEntryPtr fgArgInfo::AddRegArg(
+fgArgTabEntry* fgArgInfo::AddRegArg(
unsigned argNum, GenTreePtr node, GenTreePtr parent, regNumber regNum, unsigned numRegs, unsigned alignment)
{
- fgArgTabEntryPtr curArgTabEntry = new (compiler, CMK_fgArgInfo) fgArgTabEntry;
+ fgArgTabEntry* curArgTabEntry = new (compiler, CMK_fgArgInfo) fgArgTabEntry;
curArgTabEntry->argNum = argNum;
curArgTabEntry->node = node;
@@ -1218,17 +1218,17 @@ fgArgTabEntryPtr fgArgInfo::AddRegArg(
}
#if defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
-fgArgTabEntryPtr fgArgInfo::AddRegArg(unsigned argNum,
- GenTreePtr node,
- GenTreePtr parent,
- regNumber regNum,
- unsigned numRegs,
- unsigned alignment,
- const bool isStruct,
- const regNumber otherRegNum,
- const SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* const structDescPtr)
+fgArgTabEntry* fgArgInfo::AddRegArg(unsigned argNum,
+ GenTreePtr node,
+ GenTreePtr parent,
+ regNumber regNum,
+ unsigned numRegs,
+ unsigned alignment,
+ const bool isStruct,
+ const regNumber otherRegNum,
+ const SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* const structDescPtr)
{
- fgArgTabEntryPtr curArgTabEntry = AddRegArg(argNum, node, parent, regNum, numRegs, alignment);
+ fgArgTabEntry* curArgTabEntry = AddRegArg(argNum, node, parent, regNum, numRegs, alignment);
assert(curArgTabEntry != nullptr);
// The node of the ArgTabEntry could change after remorphing - it could be rewritten to a cpyblk or a
@@ -1248,14 +1248,13 @@ fgArgTabEntryPtr fgArgInfo::AddRegArg(unsigned
}
#endif // defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
-fgArgTabEntryPtr fgArgInfo::AddStkArg(unsigned argNum,
- GenTreePtr node,
- GenTreePtr parent,
- unsigned numSlots,
- unsigned alignment
- FEATURE_UNIX_AMD64_STRUCT_PASSING_ONLY_ARG(const bool isStruct))
+fgArgTabEntry* fgArgInfo::AddStkArg(unsigned argNum,
+ GenTreePtr node,
+ GenTreePtr parent,
+ unsigned numSlots,
+ unsigned alignment FEATURE_UNIX_AMD64_STRUCT_PASSING_ONLY_ARG(const bool isStruct))
{
- fgArgTabEntryPtr curArgTabEntry = new (compiler, CMK_fgArgInfo) fgArgTabEntry;
+ fgArgTabEntry* curArgTabEntry = new (compiler, CMK_fgArgInfo) fgArgTabEntry;
nextSlotNum = (unsigned)roundUp(nextSlotNum, alignment);
@@ -1302,9 +1301,9 @@ void fgArgInfo::RemorphReset()
fgArgTabEntry* fgArgInfo::RemorphRegArg(
unsigned argNum, GenTreePtr node, GenTreePtr parent, regNumber regNum, unsigned numRegs, unsigned alignment)
{
- fgArgTabEntryPtr curArgTabEntry = nullptr;
- unsigned regArgInx = 0;
- unsigned inx;
+ fgArgTabEntry* curArgTabEntry = nullptr;
+ unsigned regArgInx = 0;
+ unsigned inx;
for (inx = 0; inx < argCount; inx++)
{
@@ -1373,11 +1372,11 @@ fgArgTabEntry* fgArgInfo::RemorphRegArg(
void fgArgInfo::RemorphStkArg(
unsigned argNum, GenTreePtr node, GenTreePtr parent, unsigned numSlots, unsigned alignment)
{
- fgArgTabEntryPtr curArgTabEntry = nullptr;
- bool isRegArg = false;
- unsigned regArgInx = 0;
- GenTreePtr argx;
- unsigned inx;
+ fgArgTabEntry* curArgTabEntry = nullptr;
+ bool isRegArg = false;
+ unsigned regArgInx = 0;
+ GenTreePtr argx;
+ unsigned inx;
for (inx = 0; inx < argCount; inx++)
{
@@ -1456,7 +1455,7 @@ void fgArgInfo::RemorphStkArg(
void fgArgInfo::SplitArg(unsigned argNum, unsigned numRegs, unsigned numSlots)
{
- fgArgTabEntryPtr curArgTabEntry = nullptr;
+ fgArgTabEntry* curArgTabEntry = nullptr;
assert(argNum < argCount);
for (unsigned inx = 0; inx < argCount; inx++)
{
@@ -1489,7 +1488,7 @@ void fgArgInfo::SplitArg(unsigned argNum, unsigned numRegs, unsigned numSlots)
void fgArgInfo::EvalToTmp(unsigned argNum, unsigned tmpNum, GenTreePtr newNode)
{
- fgArgTabEntryPtr curArgTabEntry = nullptr;
+ fgArgTabEntry* curArgTabEntry = nullptr;
assert(argNum < argCount);
for (unsigned inx = 0; inx < argCount; inx++)
{
@@ -1513,7 +1512,7 @@ void fgArgInfo::ArgsComplete()
for (unsigned curInx = 0; curInx < argCount; curInx++)
{
- fgArgTabEntryPtr curArgTabEntry = argTable[curInx];
+ fgArgTabEntry* curArgTabEntry = argTable[curInx];
assert(curArgTabEntry != nullptr);
GenTreePtr argx = curArgTabEntry->node;
@@ -1574,7 +1573,7 @@ void fgArgInfo::ArgsComplete()
// we require that they be evaluated into temps
for (unsigned prevInx = 0; prevInx < curInx; prevInx++)
{
- fgArgTabEntryPtr prevArgTabEntry = argTable[prevInx];
+ fgArgTabEntry* prevArgTabEntry = argTable[prevInx];
assert(prevArgTabEntry->argNum < curArgTabEntry->argNum);
assert(prevArgTabEntry->node);
@@ -1635,7 +1634,7 @@ void fgArgInfo::ArgsComplete()
// All previous arguments may need to be evaluated into temps
for (unsigned prevInx = 0; prevInx < curInx; prevInx++)
{
- fgArgTabEntryPtr prevArgTabEntry = argTable[prevInx];
+ fgArgTabEntry* prevArgTabEntry = argTable[prevInx];
assert(prevArgTabEntry->argNum < curArgTabEntry->argNum);
assert(prevArgTabEntry->node);
@@ -1786,7 +1785,7 @@ void fgArgInfo::ArgsComplete()
{
for (unsigned curInx = 0; curInx < argCount; curInx++)
{
- fgArgTabEntryPtr curArgTabEntry = argTable[curInx];
+ fgArgTabEntry* curArgTabEntry = argTable[curInx];
assert(curArgTabEntry != nullptr);
GenTreePtr argx = curArgTabEntry->node;
@@ -1887,7 +1886,7 @@ void fgArgInfo::SortArgs()
{
curInx--;
- fgArgTabEntryPtr curArgTabEntry = argTable[curInx];
+ fgArgTabEntry* curArgTabEntry = argTable[curInx];
if (curArgTabEntry->regNum != REG_STK)
{
@@ -1929,7 +1928,7 @@ void fgArgInfo::SortArgs()
//
for (curInx = begTab; curInx <= endTab; curInx++)
{
- fgArgTabEntryPtr curArgTabEntry = argTable[curInx];
+ fgArgTabEntry* curArgTabEntry = argTable[curInx];
// Skip any already processed args
//
@@ -1969,7 +1968,7 @@ void fgArgInfo::SortArgs()
//
for (curInx = begTab; curInx <= endTab; curInx++)
{
- fgArgTabEntryPtr curArgTabEntry = argTable[curInx];
+ fgArgTabEntry* curArgTabEntry = argTable[curInx];
// Skip any already processed args
//
@@ -2005,7 +2004,7 @@ void fgArgInfo::SortArgs()
{
curInx--;
- fgArgTabEntryPtr curArgTabEntry = argTable[curInx];
+ fgArgTabEntry* curArgTabEntry = argTable[curInx];
// Skip any already processed args
//
@@ -2041,15 +2040,15 @@ void fgArgInfo::SortArgs()
{
/* Find the most expensive arg remaining and evaluate it next */
- fgArgTabEntryPtr expensiveArgTabEntry = nullptr;
- unsigned expensiveArg = UINT_MAX;
- unsigned expensiveArgCost = 0;
+ fgArgTabEntry* expensiveArgTabEntry = nullptr;
+ unsigned expensiveArg = UINT_MAX;
+ unsigned expensiveArgCost = 0;
// [We use a forward iterator pattern]
//
for (curInx = begTab; curInx <= endTab; curInx++)
{
- fgArgTabEntryPtr curArgTabEntry = argTable[curInx];
+ fgArgTabEntry* curArgTabEntry = argTable[curInx];
// Skip any already processed args
//
@@ -2126,7 +2125,7 @@ void fgArgInfo::SortArgs()
unsigned regInx = 0;
for (curInx = 0; curInx < argCount; curInx++)
{
- fgArgTabEntryPtr curArgTabEntry = argTable[curInx];
+ fgArgTabEntry* curArgTabEntry = argTable[curInx];
if (curArgTabEntry->regNum != REG_STK)
{
@@ -2146,7 +2145,7 @@ void fgArgInfo::Dump(Compiler* compiler)
{
for (unsigned curInx = 0; curInx < ArgCount(); curInx++)
{
- fgArgTabEntryPtr curArgEntry = ArgTable()[curInx];
+ fgArgTabEntry* curArgEntry = ArgTable()[curInx];
curArgEntry->Dump();
}
}
@@ -2283,7 +2282,7 @@ void fgArgInfo::EvalArgsToTemps()
GenTreeArgList* tmpRegArgNext = nullptr;
for (unsigned curInx = 0; curInx < argCount; curInx++)
{
- fgArgTabEntryPtr curArgTabEntry = argTable[curInx];
+ fgArgTabEntry* curArgTabEntry = argTable[curInx];
GenTreePtr argx = curArgTabEntry->node;
GenTreePtr setupArg = nullptr;
@@ -2593,7 +2592,7 @@ void fgArgInfo::EvalArgsToTemps()
printf("\nShuffled argument table: ");
for (unsigned curInx = 0; curInx < argCount; curInx++)
{
- fgArgTabEntryPtr curArgTabEntry = argTable[curInx];
+ fgArgTabEntry* curArgTabEntry = argTable[curInx];
if (curArgTabEntry->regNum != REG_STK)
{
@@ -3368,7 +3367,7 @@ GenTreeCall* Compiler::fgMorphArgs(GenTreeCall* call)
bool isNonStandard = false;
regNumber nonStdRegNum = REG_NA;
- fgArgTabEntryPtr argEntry = nullptr;
+ fgArgTabEntry* argEntry = nullptr;
if (reMorphing)
{
@@ -3473,7 +3472,7 @@ GenTreeCall* Compiler::fgMorphArgs(GenTreeCall* call)
{
#if defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
// Get the struct description for the already completed struct argument.
- fgArgTabEntryPtr fgEntryPtr = gtArgEntryByNode(call, argx);
+ fgArgTabEntry* fgEntryPtr = gtArgEntryByNode(call, argx);
assert(fgEntryPtr != nullptr);
// As described in few other places, this can happen when the argx was morphed
@@ -4239,7 +4238,7 @@ GenTreeCall* Compiler::fgMorphArgs(GenTreeCall* call)
#endif
#endif
- fgArgTabEntryPtr newArgEntry;
+ fgArgTabEntry* newArgEntry;
if (reMorphing)
{
// This is a register argument - possibly update it in the table
@@ -4374,9 +4373,9 @@ GenTreeCall* Compiler::fgMorphArgs(GenTreeCall* call)
GenTreeFieldList(argx->gtOp.gtOp1, offsetof(CORINFO_RefAny, dataPtr), TYP_BYREF, nullptr);
(void)new (this, GT_FIELD_LIST)
GenTreeFieldList(argx->gtOp.gtOp2, offsetof(CORINFO_RefAny, type), TYP_I_IMPL, fieldList);
- fgArgTabEntryPtr fp = Compiler::gtArgEntryByNode(call, argx);
- fp->node = fieldList;
- args->gtOp.gtOp1 = fieldList;
+ fgArgTabEntry* fp = Compiler::gtArgEntryByNode(call, argx);
+ fp->node = fieldList;
+ args->gtOp.gtOp1 = fieldList;
#else // !_TARGET_X86_
@@ -4430,9 +4429,9 @@ GenTreeCall* Compiler::fgMorphArgs(GenTreeCall* call)
lcl->gtType = fieldVarDsc->lvType;
fieldList = new (this, GT_FIELD_LIST)
GenTreeFieldList(lcl, fieldVarDsc->lvFldOffset, fieldVarDsc->lvType, nullptr);
- fgArgTabEntryPtr fp = Compiler::gtArgEntryByNode(call, argx);
- fp->node = fieldList;
- args->gtOp.gtOp1 = fieldList;
+ fgArgTabEntry* fp = Compiler::gtArgEntryByNode(call, argx);
+ fp->node = fieldList;
+ args->gtOp.gtOp1 = fieldList;
}
else
{
@@ -4636,7 +4635,7 @@ void Compiler::fgMorphSystemVStructArgs(GenTreeCall* call, bool hasStructArgumen
if (hasStructArgument)
{
- fgArgInfoPtr allArgInfo = call->fgArgInfo;
+ fgArgInfo* allArgInfo = call->fgArgInfo;
for (args = call->gtCallArgs; args != nullptr; args = args->gtOp.gtOp2)
{
@@ -4645,8 +4644,8 @@ void Compiler::fgMorphSystemVStructArgs(GenTreeCall* call, bool hasStructArgumen
// The tree from the gtCallLateArgs list is passed to the callee. The fgArgEntry node contains the mapping
// between the nodes in both lists. If the arg is not a late arg, the fgArgEntry->node points to itself,
// otherwise points to the list in the late args list.
- bool isLateArg = (args->gtOp.gtOp1->gtFlags & GTF_LATE_ARG) != 0;
- fgArgTabEntryPtr fgEntryPtr = gtArgEntryByNode(call, args->gtOp.gtOp1);
+ bool isLateArg = (args->gtOp.gtOp1->gtFlags & GTF_LATE_ARG) != 0;
+ fgArgTabEntry* fgEntryPtr = gtArgEntryByNode(call, args->gtOp.gtOp1);
assert(fgEntryPtr != nullptr);
GenTreePtr argx = fgEntryPtr->node;
GenTreePtr lateList = nullptr;
@@ -4764,8 +4763,8 @@ void Compiler::fgMorphSystemVStructArgs(GenTreeCall* call, bool hasStructArgumen
if (argx != arg)
{
- bool isLateArg = (args->gtOp.gtOp1->gtFlags & GTF_LATE_ARG) != 0;
- fgArgTabEntryPtr fgEntryPtr = gtArgEntryByNode(call, args->gtOp.gtOp1);
+ bool isLateArg = (args->gtOp.gtOp1->gtFlags & GTF_LATE_ARG) != 0;
+ fgArgTabEntry* fgEntryPtr = gtArgEntryByNode(call, args->gtOp.gtOp1);
assert(fgEntryPtr != nullptr);
GenTreePtr argx = fgEntryPtr->node;
GenTreePtr lateList = nullptr;
@@ -4819,10 +4818,10 @@ void Compiler::fgMorphSystemVStructArgs(GenTreeCall* call, bool hasStructArgumen
//
void Compiler::fgMorphMultiregStructArgs(GenTreeCall* call)
{
- bool foundStructArg = false;
- unsigned initialFlags = call->gtFlags;
- unsigned flagsSummary = 0;
- fgArgInfoPtr allArgInfo = call->fgArgInfo;
+ bool foundStructArg = false;
+ unsigned initialFlags = call->gtFlags;
+ unsigned flagsSummary = 0;
+ fgArgInfo* allArgInfo = call->fgArgInfo;
// Currently ARM64/ARM is using this method to morph the MultiReg struct args
// in the future AMD64_UNIX will also use this method
@@ -4846,8 +4845,8 @@ void Compiler::fgMorphMultiregStructArgs(GenTreeCall* call)
// The tree from the gtCallLateArgs list is passed to the callee. The fgArgEntry node contains the mapping
// between the nodes in both lists. If the arg is not a late arg, the fgArgEntry->node points to itself,
// otherwise points to the list in the late args list.
- bool isLateArg = (args->gtOp.gtOp1->gtFlags & GTF_LATE_ARG) != 0;
- fgArgTabEntryPtr fgEntryPtr = gtArgEntryByNode(call, args->gtOp.gtOp1);
+ bool isLateArg = (args->gtOp.gtOp1->gtFlags & GTF_LATE_ARG) != 0;
+ fgArgTabEntry* fgEntryPtr = gtArgEntryByNode(call, args->gtOp.gtOp1);
assert(fgEntryPtr != nullptr);
GenTreePtr argx = fgEntryPtr->node;
GenTreePtr lateList = nullptr;
@@ -4929,7 +4928,7 @@ void Compiler::fgMorphMultiregStructArgs(GenTreeCall* call)
// indirections.
// Currently the implementation handles ARM64/ARM and will NYI for other architectures.
//
-GenTreePtr Compiler::fgMorphMultiregStructArg(GenTreePtr arg, fgArgTabEntryPtr fgEntryPtr)
+GenTreePtr Compiler::fgMorphMultiregStructArg(GenTreePtr arg, fgArgTabEntry* fgEntryPtr)
{
assert(varTypeIsStruct(arg->TypeGet()));
@@ -5505,10 +5504,10 @@ void Compiler::fgMakeOutgoingStructArgCopy(
// struct parameters if they are passed as arguments to a tail call.
if (!call->IsTailCallViaHelper() && (varDsc->lvRefCnt == 1) && !fgMightHaveLoop())
{
- varDsc->lvRefCnt = 0;
- args->gtOp.gtOp1 = lcl;
- fgArgTabEntryPtr fp = Compiler::gtArgEntryByNode(call, argx);
- fp->node = lcl;
+ varDsc->lvRefCnt = 0;
+ args->gtOp.gtOp1 = lcl;
+ fgArgTabEntry* fp = Compiler::gtArgEntryByNode(call, argx);
+ fp->node = lcl;
JITDUMP("did not have to make outgoing copy for V%2d", varNum);
return;
@@ -8183,8 +8182,8 @@ void Compiler::fgMorphRecursiveFastTailCallIntoLoop(BasicBlock* block, GenTreeCa
else
{
// This is an actual argument that needs to be assigned to the corresponding caller parameter.
- fgArgTabEntryPtr curArgTabEntry = gtArgEntryByArgNum(recursiveTailCall, earlyArgIndex);
- GenTreePtr paramAssignStmt =
+ fgArgTabEntry* curArgTabEntry = gtArgEntryByArgNum(recursiveTailCall, earlyArgIndex);
+ GenTreePtr paramAssignStmt =
fgAssignRecursiveCallArgToCallerParam(earlyArg, curArgTabEntry, block, callILOffset,
tmpAssignmentInsertionPoint, paramAssignmentInsertionPoint);
if ((tmpAssignmentInsertionPoint == last) && (paramAssignStmt != nullptr))
@@ -8202,9 +8201,9 @@ void Compiler::fgMorphRecursiveFastTailCallIntoLoop(BasicBlock* block, GenTreeCa
(lateArgIndex++, lateArgs = lateArgs->Rest()))
{
// A late argument is an actual argument that needs to be assigned to the corresponding caller's parameter.
- GenTreePtr lateArg = lateArgs->Current();
- fgArgTabEntryPtr curArgTabEntry = gtArgEntryByLateArgIndex(recursiveTailCall, lateArgIndex);
- GenTreePtr paramAssignStmt =
+ GenTreePtr lateArg = lateArgs->Current();
+ fgArgTabEntry* curArgTabEntry = gtArgEntryByLateArgIndex(recursiveTailCall, lateArgIndex);
+ GenTreePtr paramAssignStmt =
fgAssignRecursiveCallArgToCallerParam(lateArg, curArgTabEntry, block, callILOffset,
tmpAssignmentInsertionPoint, paramAssignmentInsertionPoint);
@@ -8295,12 +8294,12 @@ void Compiler::fgMorphRecursiveFastTailCallIntoLoop(BasicBlock* block, GenTreeCa
// Return Value:
// parameter assignment statement if one was inserted; nullptr otherwise.
-GenTreePtr Compiler::fgAssignRecursiveCallArgToCallerParam(GenTreePtr arg,
- fgArgTabEntryPtr argTabEntry,
- BasicBlock* block,
- IL_OFFSETX callILOffset,
- GenTreePtr tmpAssignmentInsertionPoint,
- GenTreePtr paramAssignmentInsertionPoint)
+GenTreePtr Compiler::fgAssignRecursiveCallArgToCallerParam(GenTreePtr arg,
+ fgArgTabEntry* argTabEntry,
+ BasicBlock* block,
+ IL_OFFSETX callILOffset,
+ GenTreePtr tmpAssignmentInsertionPoint,
+ GenTreePtr paramAssignmentInsertionPoint)
{
// Call arguments should be assigned to temps first and then the temps should be assigned to parameters because
// some argument trees may reference parameters directly.
diff --git a/src/jit/optcse.cpp b/src/jit/optcse.cpp
index 7c42852cec..7a72558524 100644
--- a/src/jit/optcse.cpp
+++ b/src/jit/optcse.cpp
@@ -544,7 +544,7 @@ unsigned Compiler::optValnumCSE_Index(GenTreePtr tree, GenTreePtr stmt)
{
if (hashDsc->csdHashValue == key)
{
- treeStmtLstPtr newElem;
+ treeStmtLst* newElem;
/* Have we started the list of matching nodes? */
@@ -912,9 +912,9 @@ void Compiler::optValnumCSE_InitDataFlow()
//
for (unsigned cnt = 0; cnt < optCSECandidateCount; cnt++)
{
- CSEdsc* dsc = optCSEtab[cnt];
- unsigned CSEindex = dsc->csdIndex;
- treeStmtLstPtr lst = dsc->csdTreeList;
+ CSEdsc* dsc = optCSEtab[cnt];
+ unsigned CSEindex = dsc->csdIndex;
+ treeStmtLst* lst = dsc->csdTreeList;
noway_assert(lst);
while (lst != nullptr)
@@ -1912,7 +1912,7 @@ public:
We also unmark nested CSE's for all uses.
*/
- Compiler::treeStmtLstPtr lst;
+ Compiler::treeStmtLst* lst;
lst = successfulCandidate->CseDsc()->csdTreeList;
noway_assert(lst);
diff --git a/src/jit/regalloc.cpp b/src/jit/regalloc.cpp
index ad06ee18e7..5130cc236e 100644
--- a/src/jit/regalloc.cpp
+++ b/src/jit/regalloc.cpp
@@ -4611,7 +4611,7 @@ regMaskTP Compiler::rpPredictTreeRegUse(GenTreePtr tree,
assert(!args->IsArgPlaceHolderNode()); // No place holders nodes are in gtCallLateArgs;
- fgArgTabEntryPtr curArgTabEntry = gtArgEntryByNode(tree->AsCall(), args);
+ fgArgTabEntry* curArgTabEntry = gtArgEntryByNode(tree->AsCall(), args);
assert(curArgTabEntry);
regNumber regNum = curArgTabEntry->regNum; // first register use to pass this argument
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-30 20:08:08 +0000