Delete GenTreePtr. (#16027)

* jit sources: Each local pointer variable must be declared on its own line.

Implement https://github.com/dotnet/coreclr/blob/master/Documentation/coding-guidelines/clr-jit-coding-conventions.md#101-pointer-declarations
Each local pointer variable must be declared on its own line.

* add constGenTreePtr

* delete GenTreePtr

* delete constGenTreePtr

* fix arm

1 files changed, 47 insertions, 47 deletions

diff --git a/src/jit/codegencommon.cpp b/src/jit/codegencommon.cpp
index e0046d2279..4c0fce504c 100644
--- a/src/jit/codegencommon.cpp
+++ b/src/jit/codegencommon.cpp
@@ -186,7 +186,7 @@ CodeGen::CodeGen(Compiler* theCompiler) : CodeGenInterface(theCompiler)
 #endif
 }
 
-void CodeGenInterface::genMarkTreeInReg(GenTreePtr tree, regNumber reg)
+void CodeGenInterface::genMarkTreeInReg(GenTree* tree, regNumber reg)
 {
     tree->gtRegNum = reg;
 #ifdef LEGACY_BACKEND
@@ -195,7 +195,7 @@ void CodeGenInterface::genMarkTreeInReg(GenTreePtr tree, regNumber reg)
 }
 
 #if CPU_LONG_USES_REGPAIR
-void CodeGenInterface::genMarkTreeInRegPair(GenTreePtr tree, regPairNo regPair)
+void CodeGenInterface::genMarkTreeInRegPair(GenTree* tree, regPairNo regPair)
 {
     tree->gtRegPair = regPair;
 #ifdef LEGACY_BACKEND
@@ -463,7 +463,7 @@ void CodeGen::genPrepForEHCodegen()
 #endif        // FEATURE_EH_CALLFINALLY_THUNKS
 }
 
-void CodeGenInterface::genUpdateLife(GenTreePtr tree)
+void CodeGenInterface::genUpdateLife(GenTree* tree)
 {
     compiler->compUpdateLife</*ForCodeGen*/ true>(tree);
 }
@@ -478,10 +478,10 @@ void CodeGenInterface::genUpdateLife(VARSET_VALARG_TP newLife)
 // "tree" MUST occur in the current statement, AFTER the most recent
 // update of compiler->compCurLifeTree and compiler->compCurLife.
 //
-VARSET_VALRET_TP CodeGen::genUpdateLiveSetForward(GenTreePtr tree)
+VARSET_VALRET_TP CodeGen::genUpdateLiveSetForward(GenTree* tree)
 {
-    VARSET_TP  startLiveSet(VarSetOps::MakeCopy(compiler, compiler->compCurLife));
-    GenTreePtr startNode;
+    VARSET_TP startLiveSet(VarSetOps::MakeCopy(compiler, compiler->compCurLife));
+    GenTree*  startNode;
     assert(tree != compiler->compCurLifeTree);
     if (compiler->compCurLifeTree == nullptr)
     {
@@ -501,7 +501,7 @@ VARSET_VALRET_TP CodeGen::genUpdateLiveSetForward(GenTreePtr tree)
 // 1. "first" must occur after compiler->compCurLifeTree in execution order for the current statement
 // 2. "second" must occur after "first" in the current statement
 //
-regMaskTP CodeGen::genNewLiveRegMask(GenTreePtr first, GenTreePtr second)
+regMaskTP CodeGen::genNewLiveRegMask(GenTree* first, GenTree* second)
 {
     // First, compute the liveset after "first"
     VARSET_TP firstLiveSet = genUpdateLiveSetForward(first);
@@ -537,7 +537,7 @@ regMaskTP CodeGenInterface::genGetRegMask(const LclVarDsc* varDsc)
 
 // Return the register mask for the given lclVar or regVar tree node
 // inline
-regMaskTP CodeGenInterface::genGetRegMask(GenTreePtr tree)
+regMaskTP CodeGenInterface::genGetRegMask(GenTree* tree)
 {
     assert(tree->gtOper == GT_LCL_VAR || tree->gtOper == GT_REG_VAR);
 
@@ -565,7 +565,7 @@ regMaskTP CodeGenInterface::genGetRegMask(GenTreePtr tree)
 // It might be both going live and dying (that is, it is a dead store) under MinOpts.
 // Update regSet.rsMaskVars accordingly.
 // inline
-void CodeGenInterface::genUpdateRegLife(const LclVarDsc* varDsc, bool isBorn, bool isDying DEBUGARG(GenTreePtr tree))
+void CodeGenInterface::genUpdateRegLife(const LclVarDsc* varDsc, bool isBorn, bool isDying DEBUGARG(GenTree* tree))
 {
 #if FEATURE_STACK_FP_X87
     // The stack fp reg vars are handled elsewhere
@@ -758,13 +758,13 @@ regMaskTP Compiler::compNoGCHelperCallKillSet(CorInfoHelpFunc helper)
 // regSet.rsMaskVars as well)
 // if the given lclVar (or indir(addr(local)))/regVar node is going live (being born) or dying.
 template <bool ForCodeGen>
-void Compiler::compUpdateLifeVar(GenTreePtr tree, VARSET_TP* pLastUseVars)
+void Compiler::compUpdateLifeVar(GenTree* tree, VARSET_TP* pLastUseVars)
 {
-    GenTreePtr indirAddrLocal = fgIsIndirOfAddrOfLocal(tree);
+    GenTree* indirAddrLocal = fgIsIndirOfAddrOfLocal(tree);
     assert(tree->OperIsNonPhiLocal() || indirAddrLocal != nullptr);
 
     // Get the local var tree -- if "tree" is "Ldobj(addr(x))", or "ind(addr(x))" this is "x", else it's "tree".
-    GenTreePtr lclVarTree = indirAddrLocal;
+    GenTree* lclVarTree = indirAddrLocal;
     if (lclVarTree == nullptr)
     {
         lclVarTree = tree;
@@ -797,7 +797,7 @@ void Compiler::compUpdateLifeVar(GenTreePtr tree, VARSET_TP* pLastUseVars)
         // ifdef'ed out for AMD64).
         else if (!varDsc->lvIsStructField)
         {
-            GenTreePtr prevTree;
+            GenTree* prevTree;
             for (prevTree = tree->gtPrev;
                  prevTree != NULL && prevTree != compCurLifeTree;
                  prevTree = prevTree->gtPrev)
@@ -1076,10 +1076,10 @@ void Compiler::compUpdateLifeVar(GenTreePtr tree, VARSET_TP* pLastUseVars)
 }
 
 // Need an explicit instantiation.
-template void Compiler::compUpdateLifeVar<false>(GenTreePtr tree, VARSET_TP* pLastUseVars);
+template void Compiler::compUpdateLifeVar<false>(GenTree* tree, VARSET_TP* pLastUseVars);
 
 template <bool ForCodeGen>
-void Compiler::compChangeLife(VARSET_VALARG_TP newLife DEBUGARG(GenTreePtr tree))
+void Compiler::compChangeLife(VARSET_VALARG_TP newLife DEBUGARG(GenTree* tree))
 {
     LclVarDsc* varDsc;
 
@@ -1219,7 +1219,7 @@ void Compiler::compChangeLife(VARSET_VALARG_TP newLife DEBUGARG(GenTreePtr tree)
 }
 
 // Need an explicit instantiation.
-template void Compiler::compChangeLife<true>(VARSET_VALARG_TP newLife DEBUGARG(GenTreePtr tree));
+template void Compiler::compChangeLife<true>(VARSET_VALARG_TP newLife DEBUGARG(GenTree* tree));
 
 #ifdef LEGACY_BACKEND
 
@@ -1231,11 +1231,11 @@ template void Compiler::compChangeLife<true>(VARSET_VALARG_TP newLife DEBUGARG(G
  *  The output is the mask of integer registers that are currently
  *  alive and holding the enregistered local variables.
  */
-regMaskTP CodeGenInterface::genLiveMask(GenTreePtr tree)
+regMaskTP CodeGenInterface::genLiveMask(GenTree* tree)
 {
     regMaskTP liveMask = regSet.rsMaskVars;
 
-    GenTreePtr nextNode;
+    GenTree* nextNode;
     if (compiler->compCurLifeTree == nullptr)
     {
         assert(compiler->compCurStmt != nullptr);
@@ -1726,7 +1726,7 @@ void CodeGen::genAdjustStackLevel(BasicBlock* block)
 #ifdef _TARGET_ARMARCH_
 // return size
 // alignmentWB is out param
-unsigned CodeGenInterface::InferOpSizeAlign(GenTreePtr op, unsigned* alignmentWB)
+unsigned CodeGenInterface::InferOpSizeAlign(GenTree* op, unsigned* alignmentWB)
 {
     unsigned alignment = 0;
     unsigned opSize    = 0;
@@ -1749,7 +1749,7 @@ unsigned CodeGenInterface::InferOpSizeAlign(GenTreePtr op, unsigned* alignmentWB
 }
 // return size
 // alignmentWB is out param
-unsigned CodeGenInterface::InferStructOpSizeAlign(GenTreePtr op, unsigned* alignmentWB)
+unsigned CodeGenInterface::InferStructOpSizeAlign(GenTree* op, unsigned* alignmentWB)
 {
     unsigned alignment = 0;
     unsigned opSize    = 0;
@@ -1785,7 +1785,7 @@ unsigned CodeGenInterface::InferStructOpSizeAlign(GenTreePtr op, unsigned* align
     }
     else if (op->OperIsCopyBlkOp())
     {
-        GenTreePtr op2 = op->gtOp.gtOp2;
+        GenTree* op2 = op->gtOp.gtOp2;
 
         if (op2->OperGet() == GT_CNS_INT)
         {
@@ -1798,10 +1798,10 @@ unsigned CodeGenInterface::InferStructOpSizeAlign(GenTreePtr op, unsigned* align
             }
             else
             {
-                opSize         = (unsigned)op2->gtIntCon.gtIconVal;
-                GenTreePtr op1 = op->gtOp.gtOp1;
+                opSize       = (unsigned)op2->gtIntCon.gtIconVal;
+                GenTree* op1 = op->gtOp.gtOp1;
                 assert(op1->OperGet() == GT_LIST);
-                GenTreePtr dstAddr = op1->gtOp.gtOp1;
+                GenTree* dstAddr = op1->gtOp.gtOp1;
                 if (dstAddr->OperGet() == GT_ADDR)
                 {
                     InferStructOpSizeAlign(dstAddr->gtOp.gtOp1, &alignment);
@@ -1890,13 +1890,13 @@ unsigned CodeGenInterface::InferStructOpSizeAlign(GenTreePtr op, unsigned* align
  *                  form an address mode later on.
  */
 
-bool CodeGen::genCreateAddrMode(GenTreePtr  addr,
-                                int         mode,
-                                bool        fold,
-                                regMaskTP   regMask,
-                                bool*       revPtr,
-                                GenTreePtr* rv1Ptr,
-                                GenTreePtr* rv2Ptr,
+bool CodeGen::genCreateAddrMode(GenTree*  addr,
+                                int       mode,
+                                bool      fold,
+                                regMaskTP regMask,
+                                bool*     revPtr,
+                                GenTree** rv1Ptr,
+                                GenTree** rv2Ptr,
 #if SCALED_ADDR_MODES
                                 unsigned* mulPtr,
 #endif
@@ -1949,18 +1949,18 @@ bool CodeGen::genCreateAddrMode(GenTreePtr  addr,
         return false;
     }
 
-    GenTreePtr rv1 = nullptr;
-    GenTreePtr rv2 = nullptr;
+    GenTree* rv1 = nullptr;
+    GenTree* rv2 = nullptr;
 
-    GenTreePtr op1;
-    GenTreePtr op2;
+    GenTree* op1;
+    GenTree* op2;
 
     ssize_t cns;
 #if SCALED_ADDR_MODES
     unsigned mul;
 #endif
 
-    GenTreePtr tmp;
+    GenTree* tmp;
 
     /* What order are the sub-operands to be evaluated */
 
@@ -2447,8 +2447,8 @@ FOUND_AM:
 
         if (fold)
         {
-            ssize_t    tmpMul;
-            GenTreePtr index;
+            ssize_t  tmpMul;
+            GenTree* index;
 
             if ((rv2->gtOper == GT_MUL || rv2->gtOper == GT_LSH) && (rv2->gtOp.gtOp2->IsCnsIntOrI()))
             {
@@ -2791,7 +2791,7 @@ void CodeGen::genExitCode(BasicBlock* block)
  * For non-dbg code, we share the helper blocks created by fgAddCodeRef().
  */
 
-void CodeGen::genJumpToThrowHlpBlk(emitJumpKind jumpKind, SpecialCodeKind codeKind, GenTreePtr failBlk)
+void CodeGen::genJumpToThrowHlpBlk(emitJumpKind jumpKind, SpecialCodeKind codeKind, GenTree* failBlk)
 {
     bool useThrowHlpBlk = !compiler->opts.compDbgCode;
 
@@ -2864,7 +2864,7 @@ void CodeGen::genJumpToThrowHlpBlk(emitJumpKind jumpKind, SpecialCodeKind codeKi
  */
 
 // inline
-void CodeGen::genCheckOverflow(GenTreePtr tree)
+void CodeGen::genCheckOverflow(GenTree* tree)
 {
     // Overflow-check should be asked for this tree
     noway_assert(tree->gtOverflow());
@@ -4068,7 +4068,7 @@ CorInfoHelpFunc CodeGenInterface::genWriteBarrierHelperForWriteBarrierForm(GenTr
 //   tgt - target tree of write (e.g., GT_STOREIND)
 //   wbf - already computed write barrier form to use
 //
-void CodeGen::genGCWriteBarrier(GenTreePtr tgt, GCInfo::WriteBarrierForm wbf)
+void CodeGen::genGCWriteBarrier(GenTree* tgt, GCInfo::WriteBarrierForm wbf)
 {
     CorInfoHelpFunc helper = genWriteBarrierHelperForWriteBarrierForm(tgt, wbf);
 
@@ -4087,9 +4087,9 @@ void CodeGen::genGCWriteBarrier(GenTreePtr tgt, GCInfo::WriteBarrierForm wbf)
     CheckedWriteBarrierKinds wbKind = CWBKind_Unclassified;
     if (tgt->gtOper == GT_IND)
     {
-        GenTreePtr lcl = NULL;
+        GenTree* lcl = NULL;
 
-        GenTreePtr indArg = tgt->gtOp.gtOp1;
+        GenTree* indArg = tgt->gtOp.gtOp1;
         if (indArg->gtOper == GT_ADDR && indArg->gtOp.gtOp1->gtOper == GT_IND)
         {
             indArg = indArg->gtOp.gtOp1->gtOp.gtOp1;
@@ -11124,7 +11124,7 @@ void CodeGen::genGenerateStackProbe()
  *  Record the constant and return a tree node that yields its address.
  */
 
-GenTreePtr CodeGen::genMakeConst(const void* cnsAddr, var_types cnsType, GenTreePtr cnsTree, bool dblAlign)
+GenTree* CodeGen::genMakeConst(const void* cnsAddr, var_types cnsType, GenTree* cnsTree, bool dblAlign)
 {
     // Assign the constant an offset in the data section
     UNATIVE_OFFSET cnsSize = genTypeSize(cnsType);
@@ -11372,7 +11372,7 @@ bool Compiler::IsHfa(CORINFO_CLASS_HANDLE hClass)
 #endif
 }
 
-bool Compiler::IsHfa(GenTreePtr tree)
+bool Compiler::IsHfa(GenTree* tree)
 {
 #ifdef FEATURE_HFA
     return IsHfa(gtGetStructHandleIfPresent(tree));
@@ -11381,7 +11381,7 @@ bool Compiler::IsHfa(GenTreePtr tree)
 #endif
 }
 
-var_types Compiler::GetHfaType(GenTreePtr tree)
+var_types Compiler::GetHfaType(GenTree* tree)
 {
 #ifdef FEATURE_HFA
     return GetHfaType(gtGetStructHandleIfPresent(tree));
@@ -11390,7 +11390,7 @@ var_types Compiler::GetHfaType(GenTreePtr tree)
 #endif
 }
 
-unsigned Compiler::GetHfaCount(GenTreePtr tree)
+unsigned Compiler::GetHfaCount(GenTree* tree)
 {
     return GetHfaCount(gtGetStructHandleIfPresent(tree));
 }