Reformat jit code for Windows x64

33 files changed, 559 insertions, 556 deletions

diff --git a/src/jit/assertionprop.cpp b/src/jit/assertionprop.cpp
index 8a53278daf..159aa293f4 100644
--- a/src/jit/assertionprop.cpp
+++ b/src/jit/assertionprop.cpp
@@ -3701,18 +3701,18 @@ GenTreePtr Compiler::optAssertionProp_BndsChk(ASSERT_VALARG_TP assertions, const
     assert(tree->gtOper == GT_ARR_BOUNDS_CHECK);
 
 #ifdef FEATURE_ENABLE_NO_RANGE_CHECKS
-	if (JitConfig.JitNoRangeChks())
-	{
+    if (JitConfig.JitNoRangeChks())
+    {
 #ifdef DEBUG
-		if (verbose)
-		{
-			printf("\nFlagging check redundant due to JitNoRangeChks in BB%02u:\n", compCurBB->bbNum);
-			gtDispTree(tree, nullptr, nullptr, true);
-		}
+        if (verbose)
+        {
+            printf("\nFlagging check redundant due to JitNoRangeChks in BB%02u:\n", compCurBB->bbNum);
+            gtDispTree(tree, nullptr, nullptr, true);
+        }
 #endif // DEBUG
-		tree->gtFlags |= GTF_ARR_BOUND_INBND;
-		return nullptr;
-	}
+        tree->gtFlags |= GTF_ARR_BOUND_INBND;
+        return nullptr;
+    }
 #endif // FEATURE_ENABLE_NO_RANGE_CHECKS
 
     BitVecOps::Iter iter(apTraits, assertions);
diff --git a/src/jit/block.cpp b/src/jit/block.cpp
index 2d37754ec5..cf2a107479 100644
--- a/src/jit/block.cpp
+++ b/src/jit/block.cpp
@@ -667,7 +667,6 @@ GenTreeStmt* BasicBlock::lastStmt()
     return result->AsStmt();
 }
 
-
 //------------------------------------------------------------------------
 // BasicBlock::firstNode: Returns the first node in the block.
 //
diff --git a/src/jit/codegen.h b/src/jit/codegen.h
index 9a85f59c0c..e58701e716 100755
--- a/src/jit/codegen.h
+++ b/src/jit/codegen.h
@@ -48,7 +48,6 @@ public:
                                    unsigned* cnsPtr,
                                    bool      nogen = false);
 
-
 private:
 #if defined(_TARGET_XARCH_) && !FEATURE_STACK_FP_X87
     // Bit masks used in negating a float or double number.
@@ -488,14 +487,14 @@ protected:
     void genAmd64EmitterUnitTests();
 #endif
 
-//-------------------------------------------------------------------------
-//
-// End prolog/epilog generation
-//
-//-------------------------------------------------------------------------
+    //-------------------------------------------------------------------------
+    //
+    // End prolog/epilog generation
+    //
+    //-------------------------------------------------------------------------
 
-    void genSinglePush();
-    void genSinglePop();
+    void      genSinglePush();
+    void      genSinglePop();
     regMaskTP genPushRegs(regMaskTP regs, regMaskTP* byrefRegs, regMaskTP* noRefRegs);
     void genPopRegs(regMaskTP regs, regMaskTP byrefRegs, regMaskTP noRefRegs);
 
diff --git a/src/jit/codegenarm.cpp b/src/jit/codegenarm.cpp
index 4e7a149068..79c19fa0bf 100644
--- a/src/jit/codegenarm.cpp
+++ b/src/jit/codegenarm.cpp
@@ -849,7 +849,8 @@ void CodeGen::genCodeForBBlist()
     if (compiler->verbose)
     {
         printf("\n# ");
-        printf("compCycleEstimate = %6d, compSizeEstimate = %5d ", compiler->compCycleEstimate, compiler->compSizeEstimate);
+        printf("compCycleEstimate = %6d, compSizeEstimate = %5d ", compiler->compCycleEstimate,
+               compiler->compSizeEstimate);
         printf("%s\n", compiler->info.compFullName);
     }
 #endif
diff --git a/src/jit/codegenarm64.cpp b/src/jit/codegenarm64.cpp
index 88657996e3..0e013bfd76 100644
--- a/src/jit/codegenarm64.cpp
+++ b/src/jit/codegenarm64.cpp
@@ -6802,8 +6802,8 @@ void CodeGen::genPutArgStk(GenTreePtr treeNode)
                 var_types type = nextArgNode->TypeGet();
                 emitAttr  attr = emitTypeSize(type);
 
-                // Emit store instructions to store the registers produced by the GT_FIELD_LIST into the outgoing argument
-                // area
+                // Emit store instructions to store the registers produced by the GT_FIELD_LIST into the outgoing
+                // argument area
                 emit->emitIns_S_R(ins_Store(type), attr, reg, varNumOut, argOffsetOut);
                 argOffsetOut += EA_SIZE_IN_BYTES(attr);
                 assert(argOffsetOut <= argOffsetMax); // We can't write beyound the outgoing area area
diff --git a/src/jit/codegencommon.cpp b/src/jit/codegencommon.cpp
index 799498a8d0..a9e43e8f0e 100755
--- a/src/jit/codegencommon.cpp
+++ b/src/jit/codegencommon.cpp
@@ -104,7 +104,7 @@ CodeGen::CodeGen(Compiler* theCompiler) : CodeGenInterface(theCompiler)
 #endif // defined(_TARGET_XARCH_) && !FEATURE_STACK_FP_X87
 
 #if defined(FEATURE_PUT_STRUCT_ARG_STK) && !defined(_TARGET_X86_)
-	m_stkArgVarNum = BAD_VAR_NUM;
+    m_stkArgVarNum = BAD_VAR_NUM;
 #endif
 
     regTracker.rsTrackInit(compiler, &regSet);
@@ -7577,9 +7577,9 @@ void CodeGen::genProfilingLeaveCallback(unsigned helper /*= CORINFO_HELP_PROF_FC
     bool     r0Trashed;
     emitAttr attr = EA_UNKNOWN;
 
-    if (compiler->info.compRetType == TYP_VOID ||
-        (!compiler->info.compIsVarArgs && !compiler->opts.compUseSoftFP && (varTypeIsFloating(compiler->info.compRetType) ||
-                                           compiler->IsHfa(compiler->info.compMethodInfo->args.retTypeClass))))
+    if (compiler->info.compRetType == TYP_VOID || (!compiler->info.compIsVarArgs && !compiler->opts.compUseSoftFP &&
+                                                   (varTypeIsFloating(compiler->info.compRetType) ||
+                                                    compiler->IsHfa(compiler->info.compMethodInfo->args.retTypeClass))))
     {
         r0Trashed = false;
     }
@@ -10893,7 +10893,9 @@ regMaskTP CodeGen::genPushRegs(regMaskTP regs, regMaskTP* byrefRegs, regMaskTP*
     *noRefRegs = RBM_NONE;
 
     if (regs == RBM_NONE)
+    {
         return RBM_NONE;
+    }
 
 #if FEATURE_FIXED_OUT_ARGS
 
@@ -10961,7 +10963,9 @@ regMaskTP CodeGen::genPushRegs(regMaskTP regs, regMaskTP* byrefRegs, regMaskTP*
 void CodeGen::genPopRegs(regMaskTP regs, regMaskTP byrefRegs, regMaskTP noRefRegs)
 {
     if (regs == RBM_NONE)
+    {
         return;
+    }
 
 #if FEATURE_FIXED_OUT_ARGS
 
diff --git a/src/jit/codegenlinear.h b/src/jit/codegenlinear.h
index 1c14f660a6..273685baff 100644
--- a/src/jit/codegenlinear.h
+++ b/src/jit/codegenlinear.h
@@ -226,7 +226,7 @@ bool genIsRegCandidateLocal(GenTreePtr tree)
 #ifdef FEATURE_PUT_STRUCT_ARG_STK
 #ifdef _TARGET_X86_
 bool m_pushStkArg;
-#else // !_TARGET_X86_
+#else  // !_TARGET_X86_
 unsigned m_stkArgVarNum;
 #endif // !_TARGET_X86_
 unsigned m_stkArgOffset;
diff --git a/src/jit/compiler.cpp b/src/jit/compiler.cpp
index 3117d9eafd..c94ce3d30e 100644
--- a/src/jit/compiler.cpp
+++ b/src/jit/compiler.cpp
@@ -1252,8 +1252,8 @@ void Compiler::compShutdown()
             // Let's not show anything below a threshold
             if (pct >= 0.5)
             {
-                fprintf(fout, "    GT_%-17s   %7u (%4.1lf%%) %3u bytes each\n",
-                              GenTree::OpName((genTreeOps)op), cnt, pct, siz);
+                fprintf(fout, "    GT_%-17s   %7u (%4.1lf%%) %3u bytes each\n", GenTree::OpName((genTreeOps)op), cnt,
+                        pct, siz);
                 rem_total -= cnt;
             }
             else
@@ -1266,16 +1266,16 @@ void Compiler::compShutdown()
         }
         if (rem_total > 0)
         {
-            fprintf(fout, "    All other GT_xxx ...   %7u (%4.1lf%%) ... %4.1lf%% small + %4.1lf%% large\n",
-                          rem_total, 100.0 * rem_total / gtc, 100.0 * rem_small / gtc, 100.0 * rem_large / gtc);
+            fprintf(fout, "    All other GT_xxx ...   %7u (%4.1lf%%) ... %4.1lf%% small + %4.1lf%% large\n", rem_total,
+                    100.0 * rem_total / gtc, 100.0 * rem_small / gtc, 100.0 * rem_large / gtc);
         }
         fprintf(fout, "    -----------------------------------------------------\n");
-        fprintf(fout, "    Total    .......   %11u --ALL-- ... %4.1lf%% small + %4.1lf%% large\n",
-                      gtc, 100.0 * tot_small / gtc, 100.0 * tot_large / gtc);
+        fprintf(fout, "    Total    .......   %11u --ALL-- ... %4.1lf%% small + %4.1lf%% large\n", gtc,
+                100.0 * tot_small / gtc, 100.0 * tot_large / gtc);
         fprintf(fout, "\n");
     }
 
-#endif//COUNT_AST_OPERS
+#endif // COUNT_AST_OPERS
 
 #if DISPLAY_SIZES
 
@@ -4503,7 +4503,9 @@ void Compiler::compCompile(void** methodCodePtr, ULONG* methodCodeSize, CORJIT_F
 
 #ifdef FEATURE_JIT_METHOD_PERF
     if (pCompJitTimer)
+    {
         pCompJitTimer->Terminate(this, CompTimeSummaryInfo::s_compTimeSummary);
+    }
 #endif
 
     RecordStateAtEndOfCompilation();
@@ -4676,13 +4678,13 @@ int Compiler::compCompile(CORINFO_METHOD_HANDLE methodHnd,
 
         checkedForJitTimeLog = true;
     }
-    if ((Compiler::compJitTimeLogFilename != NULL) || (JitTimeLogCsv() != NULL))
+    if ((Compiler::compJitTimeLogFilename != nullptr) || (JitTimeLogCsv() != nullptr))
     {
         pCompJitTimer = JitTimer::Create(this, methodInfo->ILCodeSize);
     }
     else
     {
-        pCompJitTimer = NULL;
+        pCompJitTimer = nullptr;
     }
 #endif // FEATURE_JIT_METHOD_PERF
 
@@ -6963,7 +6965,9 @@ bool CompTimeSummaryInfo::IncludedInFilteredData(CompTimeInfo& info)
 void CompTimeSummaryInfo::AddInfo(CompTimeInfo& info)
 {
     if (info.m_timerFailure)
+    {
         return; // Don't update if there was a failure.
+    }
 
     CritSecHolder timeLock(s_compTimeSummaryLock);
     m_numMethods++;
@@ -7000,12 +7004,14 @@ void CompTimeSummaryInfo::AddInfo(CompTimeInfo& info)
 }
 
 // Static
-LPCWSTR Compiler::compJitTimeLogFilename = NULL;
+LPCWSTR Compiler::compJitTimeLogFilename = nullptr;
 
 void CompTimeSummaryInfo::Print(FILE* f)
 {
-    if (f == NULL)
+    if (f == nullptr)
+    {
         return;
+    }
     // Otherwise...
     double countsPerSec = CycleTimer::CyclesPerSecond();
     if (countsPerSec == 0.0)
@@ -7054,7 +7060,8 @@ void CompTimeSummaryInfo::Print(FILE* f)
         double pslop_pct = 100.0 * m_total.m_parentPhaseEndSlop * 1000.0 / countsPerSec / totTime_ms;
         if (pslop_pct >= 1.0)
         {
-            fprintf(f, "\n  'End phase slop' should be very small (if not, there's unattributed time): %9.3f Mcycles = %3.1f%% of total.\n\n",
+            fprintf(f, "\n  'End phase slop' should be very small (if not, there's unattributed time): %9.3f Mcycles = "
+                       "%3.1f%% of total.\n\n",
                     m_total.m_parentPhaseEndSlop / 1000000.0, pslop_pct);
         }
     }
@@ -7094,8 +7101,9 @@ void CompTimeSummaryInfo::Print(FILE* f)
         double fslop_ms = m_filtered.m_parentPhaseEndSlop * 1000.0 / countsPerSec;
         if (fslop_ms > 1.0)
         {
-            fprintf(f, "\n  'End phase slop' should be very small (if not, there's unattributed time): %9.3f Mcycles.\n",
-                m_filtered.m_parentPhaseEndSlop);
+            fprintf(f,
+                    "\n  'End phase slop' should be very small (if not, there's unattributed time): %9.3f Mcycles.\n",
+                    m_filtered.m_parentPhaseEndSlop);
         }
     }
 }
@@ -7169,7 +7177,7 @@ LPCWSTR Compiler::JitTimeLogCsv()
 void JitTimer::PrintCsvHeader()
 {
     LPCWSTR jitTimeLogCsv = Compiler::JitTimeLogCsv();
-    if (jitTimeLogCsv == NULL)
+    if (jitTimeLogCsv == nullptr)
     {
         return;
     }
@@ -7212,7 +7220,7 @@ extern ICorJitHost* g_jitHost;
 void JitTimer::PrintCsvMethodStats(Compiler* comp)
 {
     LPCWSTR jitTimeLogCsv = Compiler::JitTimeLogCsv();
-    if (jitTimeLogCsv == NULL)
+    if (jitTimeLogCsv == nullptr)
     {
         return;
     }
@@ -7242,7 +7250,9 @@ void JitTimer::PrintCsvMethodStats(Compiler* comp)
     for (int i = 0; i < PHASE_NUMBER_OF; i++)
     {
         if (!PhaseHasChildren[i])
+        {
             totCycles += m_info.m_cyclesByPhase[i];
+        }
         fprintf(fp, "%I64u,", m_info.m_cyclesByPhase[i]);
     }
 
@@ -7261,7 +7271,9 @@ void JitTimer::Terminate(Compiler* comp, CompTimeSummaryInfo& sum)
     for (int i = 0; i < PHASE_NUMBER_OF; i++)
     {
         if (!PhaseHasChildren[i])
+        {
             totCycles2 += m_info.m_cyclesByPhase[i];
+        }
     }
     // We include m_parentPhaseEndSlop in the next phase's time also (we probably shouldn't)
     // totCycles2 += m_info.m_parentPhaseEndSlop;
@@ -7309,7 +7321,9 @@ void Compiler::AggregateMemStats::Print(FILE* f)
 {
     fprintf(f, "For %9u methods:\n", nMethods);
     if (nMethods == 0)
+    {
         return;
+    }
     fprintf(f, "  count:       %12u (avg %7u per method)\n", allocCnt, allocCnt / nMethods);
     fprintf(f, "  alloc size : %12llu (avg %7llu per method)\n", allocSz, allocSz / nMethods);
     fprintf(f, "  max alloc  : %12llu\n", allocSzMax);
diff --git a/src/jit/compiler.h b/src/jit/compiler.h
index 2f062af463..7b5fcf6f39 100644
--- a/src/jit/compiler.h
+++ b/src/jit/compiler.h
@@ -3853,7 +3853,7 @@ public:
     //
     var_types getReturnTypeForStruct(CORINFO_CLASS_HANDLE clsHnd,
                                      structPassingKind*   wbPassStruct = nullptr,
-                                     unsigned             structSize = 0);
+                                     unsigned             structSize   = 0);
 
 #ifdef DEBUG
     // Print a representation of "vnp" or "vn" on standard output.
diff --git a/src/jit/compiler.hpp b/src/jit/compiler.hpp
index 39fb48efea..904da76cd9 100644
--- a/src/jit/compiler.hpp
+++ b/src/jit/compiler.hpp
@@ -804,7 +804,7 @@ void* GenTree::operator new(size_t sz, Compiler* comp, genTreeOps oper)
 #if SMALL_TREE_NODES
     size_t size = GenTree::s_gtNodeSizes[oper];
 #else
-    size_t size  = TREE_NODE_SZ_LARGE;
+    size_t     size  = TREE_NODE_SZ_LARGE;
 #endif
 
 #if MEASURE_NODE_SIZE
@@ -4385,8 +4385,10 @@ inline bool Compiler::lvaIsGCTracked(const LclVarDsc* varDsc)
 inline void Compiler::EndPhase(Phases phase)
 {
 #if defined(FEATURE_JIT_METHOD_PERF)
-    if (pCompJitTimer != NULL)
+    if (pCompJitTimer != nullptr)
+    {
         pCompJitTimer->EndPhase(phase);
+    }
 #endif
 #if DUMP_FLOWGRAPHS
     fgDumpFlowGraph(phase);
diff --git a/src/jit/decomposelongs.cpp b/src/jit/decomposelongs.cpp
index c3be74c74a..017fa62c3e 100644
--- a/src/jit/decomposelongs.cpp
+++ b/src/jit/decomposelongs.cpp
@@ -65,7 +65,7 @@ void DecomposeLongs::DecomposeBlock(BasicBlock* block)
     assert(block->isEmpty() || block->IsLIR());
 
     m_blockWeight = block->getBBWeight(m_compiler);
-    m_range = &LIR::AsRange(block);
+    m_range       = &LIR::AsRange(block);
     DecomposeRangeHelper();
 }
 
@@ -90,7 +90,7 @@ void DecomposeLongs::DecomposeRange(Compiler* compiler, unsigned blockWeight, LI
 
     DecomposeLongs decomposer(compiler);
     decomposer.m_blockWeight = blockWeight;
-    decomposer.m_range = &range;
+    decomposer.m_range       = &range;
 
     decomposer.DecomposeRangeHelper();
 }
@@ -286,7 +286,10 @@ GenTree* DecomposeLongs::DecomposeNode(GenTree* tree)
 // Return Value:
 //    The next node to process.
 //
-GenTree* DecomposeLongs::FinalizeDecomposition(LIR::Use& use, GenTree* loResult, GenTree* hiResult, GenTree* insertResultAfter)
+GenTree* DecomposeLongs::FinalizeDecomposition(LIR::Use& use,
+                                               GenTree*  loResult,
+                                               GenTree*  hiResult,
+                                               GenTree*  insertResultAfter)
 {
     assert(use.IsInitialized());
     assert(loResult != nullptr);
@@ -395,7 +398,7 @@ GenTree* DecomposeLongs::DecomposeStoreLclVar(LIR::Use& use)
     GenTree* tree = use.Def();
     GenTree* rhs  = tree->gtGetOp1();
     if ((rhs->OperGet() == GT_PHI) || (rhs->OperGet() == GT_CALL) ||
-            ((rhs->OperGet() == GT_MUL_LONG) && (rhs->gtFlags & GTF_MUL_64RSLT) != 0))
+        ((rhs->OperGet() == GT_MUL_LONG) && (rhs->gtFlags & GTF_MUL_64RSLT) != 0))
     {
         // GT_CALLs are not decomposed, so will not be converted to GT_LONG
         // GT_STORE_LCL_VAR = GT_CALL are handled in genMultiRegCallStoreToLocal
@@ -640,7 +643,7 @@ GenTree* DecomposeLongs::DecomposeStoreInd(LIR::Use& use)
     //      + --*  t155   long
     //      *  storeIndir long
 
-    GenTree* gtLong      = tree->gtOp.gtOp2;
+    GenTree* gtLong = tree->gtOp.gtOp2;
 
     // Save address to a temp. It is used in storeIndLow and storeIndHigh trees.
     LIR::Use address(Range(), &tree->gtOp.gtOp1, tree);
@@ -901,11 +904,11 @@ GenTree* DecomposeLongs::DecomposeShift(LIR::Use& use)
 {
     assert(use.IsInitialized());
 
-    GenTree* tree   = use.Def();
-    GenTree* gtLong = tree->gtGetOp1();
+    GenTree* tree         = use.Def();
+    GenTree* gtLong       = tree->gtGetOp1();
     GenTree* oldShiftByOp = tree->gtGetOp2();
 
-    genTreeOps oper = tree->OperGet();
+    genTreeOps oper        = tree->OperGet();
     genTreeOps shiftByOper = oldShiftByOp->OperGet();
 
     assert((oper == GT_LSH) || (oper == GT_RSH) || (oper == GT_RSZ));
@@ -979,9 +982,9 @@ GenTree* DecomposeLongs::DecomposeShift(LIR::Use& use)
 
                     // Create a GT_LONG that contains loCopy and hiOp1. This will be used in codegen to
                     // generate the shld instruction
-                    GenTree* loCopy  = m_compiler->gtNewLclvNode(loOp1LclNum, TYP_INT);
-                    GenTree* hiOp = new (m_compiler, GT_LONG) GenTreeOp(GT_LONG, TYP_LONG, loCopy, hiOp1);
-                    hiResult      = m_compiler->gtNewOperNode(GT_LSH_HI, TYP_INT, hiOp, shiftByHi);
+                    GenTree* loCopy = m_compiler->gtNewLclvNode(loOp1LclNum, TYP_INT);
+                    GenTree* hiOp   = new (m_compiler, GT_LONG) GenTreeOp(GT_LONG, TYP_LONG, loCopy, hiOp1);
+                    hiResult        = m_compiler->gtNewOperNode(GT_LSH_HI, TYP_INT, hiOp, shiftByHi);
 
                     m_compiler->lvaIncRefCnts(loCopy);
 
@@ -1339,9 +1342,9 @@ GenTree* DecomposeLongs::DecomposeUMod(LIR::Use& use)
     Range().Remove(op2);
 
     // Lo part is the GT_UMOD
-    GenTree* loResult = tree;
+    GenTree* loResult    = tree;
     loResult->gtOp.gtOp2 = loOp2;
-    loResult->gtType = TYP_INT;
+    loResult->gtType     = TYP_INT;
 
     // Set the high part to 0
     GenTree* hiResult = m_compiler->gtNewZeroConNode(TYP_INT);
diff --git a/src/jit/decomposelongs.h b/src/jit/decomposelongs.h
index f087c3ec6d..7955fc7a2e 100644
--- a/src/jit/decomposelongs.h
+++ b/src/jit/decomposelongs.h
@@ -35,7 +35,7 @@ private:
     }
 
     // Driver functions
-    void DecomposeRangeHelper();
+    void     DecomposeRangeHelper();
     GenTree* DecomposeNode(GenTree* tree);
 
     // Per-node type decompose cases
diff --git a/src/jit/earlyprop.cpp b/src/jit/earlyprop.cpp
index 5b985df2bb..966063ce32 100644
--- a/src/jit/earlyprop.cpp
+++ b/src/jit/earlyprop.cpp
@@ -189,7 +189,7 @@ void Compiler::optEarlyProp()
 
             // Walk the stmt tree in linear order to rewrite any array length reference with a
             // constant array length.
-            bool isRewritten    = false;
+            bool isRewritten = false;
             for (GenTreePtr tree = stmt->gtStmt.gtStmtList; tree != nullptr; tree = tree->gtNext)
             {
                 if (optEarlyPropRewriteTree(tree))
diff --git a/src/jit/emit.h b/src/jit/emit.h
index 8fb24bcd60..add3403380 100644
--- a/src/jit/emit.h
+++ b/src/jit/emit.h
@@ -1742,8 +1742,8 @@ private:
     BYTE* emitCurIGfreeEndp; // one byte past the last available byte in buffer
     BYTE* emitCurIGfreeBase; // first byte address
 
-    unsigned emitCurIGinsCnt; // # of collected instr's in buffer
-    unsigned emitCurIGsize;   // estimated code size of current group in bytes
+    unsigned       emitCurIGinsCnt;   // # of collected instr's in buffer
+    unsigned       emitCurIGsize;     // estimated code size of current group in bytes
     UNATIVE_OFFSET emitCurCodeOffset; // current code offset within group
     UNATIVE_OFFSET emitTotalCodeSize; // bytes of code in entire method
 
diff --git a/src/jit/emitxarch.cpp b/src/jit/emitxarch.cpp
index 6b7777a853..4f18ca8033 100644
--- a/src/jit/emitxarch.cpp
+++ b/src/jit/emitxarch.cpp
@@ -75,8 +75,8 @@ bool emitter::IsThreeOperandBinaryAVXInstruction(instruction ins)
             ins == INS_maxss || ins == INS_maxsd || ins == INS_andnps || ins == INS_andnpd || ins == INS_paddb ||
             ins == INS_paddw || ins == INS_paddd || ins == INS_paddq || ins == INS_psubb || ins == INS_psubw ||
             ins == INS_psubd || ins == INS_psubq || ins == INS_pmuludq || ins == INS_pxor || ins == INS_pmaxub ||
-            ins == INS_pminub || ins == INS_pmaxsw || ins == INS_pminsw || ins == INS_insertps || ins == INS_vinsertf128 ||
-            ins == INS_punpckldq
+            ins == INS_pminub || ins == INS_pmaxsw || ins == INS_pminsw || ins == INS_insertps ||
+            ins == INS_vinsertf128 || ins == INS_punpckldq
 
             );
 }
diff --git a/src/jit/gcencode.cpp b/src/jit/gcencode.cpp
index d243396353..91aa084f2d 100644
--- a/src/jit/gcencode.cpp
+++ b/src/jit/gcencode.cpp
@@ -27,15 +27,15 @@ ReturnKind GCTypeToReturnKind(CorInfoGCType gcType)
 {
     switch (gcType)
     {
-    case TYPE_GC_NONE:
-        return RT_Scalar;
-    case TYPE_GC_REF:
-        return RT_Object;
-    case TYPE_GC_BYREF:
-        return RT_ByRef;
-    default:
-        _ASSERTE(!"TYP_GC_OTHER is unexpected");
-        return RT_Illegal;
+        case TYPE_GC_NONE:
+            return RT_Scalar;
+        case TYPE_GC_REF:
+            return RT_Object;
+        case TYPE_GC_BYREF:
+            return RT_ByRef;
+        default:
+            _ASSERTE(!"TYP_GC_OTHER is unexpected");
+            return RT_Illegal;
     }
 }
 
@@ -43,66 +43,66 @@ ReturnKind GCInfo::getReturnKind()
 {
     switch (compiler->info.compRetType)
     {
-    case TYP_REF:
-    case TYP_ARRAY:
-        return RT_Object;
-    case TYP_BYREF:
-        return RT_ByRef;
-    case TYP_STRUCT:
-    {
-        CORINFO_CLASS_HANDLE structType = compiler->info.compMethodInfo->args.retTypeClass;
-        var_types retType = compiler->getReturnTypeForStruct(structType);
-
-        switch (retType)
-        {
-        case TYP_ARRAY:
-            _ASSERTE(false && "TYP_ARRAY unexpected from getReturnTypeForStruct()");
-            // fall through
         case TYP_REF:
+        case TYP_ARRAY:
             return RT_Object;
-
         case TYP_BYREF:
             return RT_ByRef;
-
         case TYP_STRUCT:
-            if (compiler->IsHfa(structType))
+        {
+            CORINFO_CLASS_HANDLE structType = compiler->info.compMethodInfo->args.retTypeClass;
+            var_types            retType    = compiler->getReturnTypeForStruct(structType);
+
+            switch (retType)
             {
+                case TYP_ARRAY:
+                    _ASSERTE(false && "TYP_ARRAY unexpected from getReturnTypeForStruct()");
+                // fall through
+                case TYP_REF:
+                    return RT_Object;
+
+                case TYP_BYREF:
+                    return RT_ByRef;
+
+                case TYP_STRUCT:
+                    if (compiler->IsHfa(structType))
+                    {
 #ifdef _TARGET_X86_
-                _ASSERTE(false && "HFAs not expected for X86");
+                        _ASSERTE(false && "HFAs not expected for X86");
 #endif // _TARGET_X86_
 
-                return RT_Scalar;
-            }
-            else
-            {
-                // Multi-reg return
-                BYTE gcPtrs[2] = { TYPE_GC_NONE, TYPE_GC_NONE };
-                compiler->info.compCompHnd->getClassGClayout(structType, gcPtrs);
+                        return RT_Scalar;
+                    }
+                    else
+                    {
+                        // Multi-reg return
+                        BYTE gcPtrs[2] = {TYPE_GC_NONE, TYPE_GC_NONE};
+                        compiler->info.compCompHnd->getClassGClayout(structType, gcPtrs);
 
-                ReturnKind first = GCTypeToReturnKind((CorInfoGCType)gcPtrs[0]);
-                ReturnKind second = GCTypeToReturnKind((CorInfoGCType)gcPtrs[1]);
+                        ReturnKind first  = GCTypeToReturnKind((CorInfoGCType)gcPtrs[0]);
+                        ReturnKind second = GCTypeToReturnKind((CorInfoGCType)gcPtrs[1]);
 
-                return GetStructReturnKind(first, second);
+                        return GetStructReturnKind(first, second);
+                    }
+
+#ifdef _TARGET_X86_
+                case TYP_FLOAT:
+                case TYP_DOUBLE:
+                    return RT_Float;
+#endif // _TARGET_X86_
+                default:
+                    return RT_Scalar;
             }
+        }
 
 #ifdef _TARGET_X86_
         case TYP_FLOAT:
         case TYP_DOUBLE:
             return RT_Float;
 #endif // _TARGET_X86_
+
         default:
             return RT_Scalar;
-        }
-    }
-
-#ifdef _TARGET_X86_
-    case TYP_FLOAT:
-    case TYP_DOUBLE:
-        return RT_Float;
-#endif // _TARGET_X86_
-
-    default:
-        return RT_Scalar;
     }
 }
 
@@ -194,8 +194,8 @@ static void regenLog(unsigned encoding, InfoHdr* header, InfoHdr* state)
             state->prologSize, state->epilogSize, state->epilogCount, state->epilogAtEnd, state->ediSaved,
             state->esiSaved, state->ebxSaved, state->ebpSaved, state->ebpFrame, state->interruptible,
             state->doubleAlign, state->security, state->handlers, state->localloc, state->editNcontinue, state->varargs,
-            state->profCallbacks, state->genericsContext, state->genericsContextIsMethodDesc, 
-            state->returnKind, state->argCount, state->frameSize,
+            state->profCallbacks, state->genericsContext, state->genericsContextIsMethodDesc, state->returnKind,
+            state->argCount, state->frameSize,
             (state->untrackedCnt <= SET_UNTRACKED_MAX) ? state->untrackedCnt : HAS_UNTRACKED,
             (state->varPtrTableSize == 0) ? 0 : HAS_VARPTR,
             (state->gsCookieOffset == INVALID_GS_COOKIE_OFFSET) ? 0 : HAS_GS_COOKIE_OFFSET,
@@ -351,11 +351,11 @@ static int bigEncoding4(unsigned cur, unsigned tgt, unsigned max)
     return cnt;
 }
 
-BYTE FASTCALL encodeHeaderNext(const InfoHdr& header, InfoHdr* state, BYTE &codeSet)
+BYTE FASTCALL encodeHeaderNext(const InfoHdr& header, InfoHdr* state, BYTE& codeSet)
 {
     BYTE encoding = 0xff;
-    codeSet = 1; // codeSet is 1 or 2, depending on whether the returned encoding 
-                 // corresponds to InfoHdrAdjust, or InfoHdrAdjust2 enumerations.
+    codeSet       = 1; // codeSet is 1 or 2, depending on whether the returned encoding
+                       // corresponds to InfoHdrAdjust, or InfoHdrAdjust2 enumerations.
 
     if (state->argCount != header.argCount)
     {
@@ -638,8 +638,8 @@ BYTE FASTCALL encodeHeaderNext(const InfoHdr& header, InfoHdr* state, BYTE &code
     if (GCInfoEncodesReturnKind() && (state->returnKind != header.returnKind))
     {
         state->returnKind = header.returnKind;
-        codeSet = 2; // Two byte encoding
-        encoding = header.returnKind;
+        codeSet           = 2; // Two byte encoding
+        encoding          = header.returnKind;
         _ASSERTE(encoding < SET_RET_KIND_MAX);
         goto DO_RETURN;
     }
@@ -686,19 +686,20 @@ BYTE FASTCALL encodeHeaderNext(const InfoHdr& header, InfoHdr* state, BYTE &code
 
     if (GCInfoEncodesRevPInvokeFrame() && (state->revPInvokeOffset != header.revPInvokeOffset))
     {
-        assert(state->revPInvokeOffset == INVALID_REV_PINVOKE_OFFSET || state->revPInvokeOffset == HAS_REV_PINVOKE_FRAME_OFFSET);
+        assert(state->revPInvokeOffset == INVALID_REV_PINVOKE_OFFSET ||
+               state->revPInvokeOffset == HAS_REV_PINVOKE_FRAME_OFFSET);
 
         if (state->revPInvokeOffset == INVALID_REV_PINVOKE_OFFSET)
         {
-            // header.revPInvokeOffset is non-zero. 
+            // header.revPInvokeOffset is non-zero.
             state->revPInvokeOffset = HAS_REV_PINVOKE_FRAME_OFFSET;
-            encoding = FLIP_REV_PINVOKE_FRAME;
+            encoding                = FLIP_REV_PINVOKE_FRAME;
             goto DO_RETURN;
         }
         else if (header.revPInvokeOffset == INVALID_REV_PINVOKE_OFFSET)
         {
             state->revPInvokeOffset = INVALID_REV_PINVOKE_OFFSET;
-            encoding = FLIP_REV_PINVOKE_FRAME;
+            encoding                = FLIP_REV_PINVOKE_FRAME;
             goto DO_RETURN;
         }
     }
@@ -1297,7 +1298,7 @@ size_t GCInfo::gcInfoBlockHdrSave(
     header->genericsContextIsMethodDesc =
         header->genericsContext && (compiler->info.compMethodInfo->options & (CORINFO_GENERICS_CTXT_FROM_METHODDESC));
 
-    if (GCInfoEncodesReturnKind()) 
+    if (GCInfoEncodesReturnKind())
     {
         ReturnKind returnKind = getReturnKind();
         _ASSERTE(IsValidReturnKind(returnKind) && "Return Kind must be valid");
@@ -1368,7 +1369,7 @@ size_t GCInfo::gcInfoBlockHdrSave(
         *dest++ = headerEncoding;
 
         BYTE encoding = headerEncoding;
-        BYTE codeSet = 1;
+        BYTE codeSet  = 1;
         while (encoding & MORE_BYTES_TO_FOLLOW)
         {
             encoding = encodeHeaderNext(*header, &state, codeSet);
@@ -1376,8 +1377,7 @@ size_t GCInfo::gcInfoBlockHdrSave(
 #if REGEN_SHORTCUTS
             regenLog(headerEncoding, header, &state);
 #endif
-            _ASSERTE(codeSet == 1 || codeSet == 2 && 
-                     "Encoding must correspond to InfoHdrAdjust or InfoHdrAdjust2");
+            _ASSERTE(codeSet == 1 || codeSet == 2 && "Encoding must correspond to InfoHdrAdjust or InfoHdrAdjust2");
             if (codeSet == 2)
             {
                 *dest++ = NEXT_OPCODE | MORE_BYTES_TO_FOLLOW;
@@ -1925,12 +1925,12 @@ size_t GCInfo::gcMakeRegPtrTable(BYTE* dest, int mask, const InfoHdr& header, un
                 }
                 else
                 {
-                    /* Stack-passed arguments which are not enregistered
-                     * are always reported in this "untracked stack
-                     * pointers" section of the GC info even if lvTracked==true
-                     */
+/* Stack-passed arguments which are not enregistered
+ * are always reported in this "untracked stack
+ * pointers" section of the GC info even if lvTracked==true
+ */
 
-                    /* Has this argument been enregistered? */
+/* Has this argument been enregistered? */
 #ifndef LEGACY_BACKEND
                     if (!varDsc->lvOnFrame)
 #else  // LEGACY_BACKEND
diff --git a/src/jit/gentree.cpp b/src/jit/gentree.cpp
index fa84ae226b..a605741201 100644
--- a/src/jit/gentree.cpp
+++ b/src/jit/gentree.cpp
@@ -241,8 +241,8 @@ const char* GenTree::OpName(genTreeOps op)
 #if MEASURE_NODE_SIZE && SMALL_TREE_NODES
 
 static const char* opStructNames[] = {
-    #define GTNODE(en, sn, st, cm, ok) #st,
-    #include "gtlist.h"
+#define GTNODE(en, sn, st, cm, ok) #st,
+#include "gtlist.h"
 };
 
 const char* GenTree::OpStructName(genTreeOps op)
@@ -269,16 +269,15 @@ unsigned char GenTree::s_gtNodeSizes[GT_COUNT + 1];
 
 #if NODEBASH_STATS || MEASURE_NODE_SIZE || COUNT_AST_OPERS
 
-unsigned char GenTree::s_gtTrueSizes[GT_COUNT+1]
-{
-    #define GTNODE(en, sn, st, cm, ok) sizeof(st),
-    #include "gtlist.h"
+unsigned char GenTree::s_gtTrueSizes[GT_COUNT + 1]{
+#define GTNODE(en, sn, st, cm, ok) sizeof(st),
+#include "gtlist.h"
 };
 
 #endif // NODEBASH_STATS || MEASURE_NODE_SIZE || COUNT_AST_OPERS
 
 #if COUNT_AST_OPERS
-LONG GenTree::s_gtNodeCounts[GT_COUNT+1] = {0};
+LONG GenTree::s_gtNodeCounts[GT_COUNT + 1] = {0};
 #endif // COUNT_AST_OPERS
 
 /* static */
@@ -298,7 +297,7 @@ void GenTree::InitNodeSize()
     // Now set all of the appropriate entries to 'large'
     CLANG_FORMAT_COMMENT_ANCHOR;
 
-    // clang-format off
+// clang-format off
 #if defined(FEATURE_HFA) || defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
     // On ARM32, ARM64 and System V for struct returning
     // there is code that does GT_ASG-tree.CopyObj call.
@@ -451,37 +450,40 @@ bool GenTree::IsNodeProperlySized() const
 
 #define BASH_HASH_SIZE 211
 
-inline hashme(genTreeOps op1, genTreeOps op2) { return ((op1 * 104729) ^ (op2 * 56569)) % BASH_HASH_SIZE; }
+inline hashme(genTreeOps op1, genTreeOps op2)
+{
+    return ((op1 * 104729) ^ (op2 * 56569)) % BASH_HASH_SIZE;
+}
 
 struct BashHashDsc
 {
-    unsigned __int32    bhFullHash; // the hash value (unique for all old->new pairs)
-    unsigned __int32    bhCount;    // the same old->new bashings seen so far
-    unsigned __int8     bhOperOld;  // original gtOper
-    unsigned __int8     bhOperNew;  // new      gtOper
+    unsigned __int32 bhFullHash; // the hash value (unique for all old->new pairs)
+    unsigned __int32 bhCount;    // the same old->new bashings seen so far
+    unsigned __int8  bhOperOld;  // original gtOper
+    unsigned __int8  bhOperNew;  // new      gtOper
 };
 
-static  BashHashDsc BashHash[BASH_HASH_SIZE];
+static BashHashDsc BashHash[BASH_HASH_SIZE];
 
-void                GenTree::RecordOperBashing(genTreeOps operOld, genTreeOps operNew)
+void GenTree::RecordOperBashing(genTreeOps operOld, genTreeOps operNew)
 {
-    unsigned        hash = hashme(operOld, operNew);
-    BashHashDsc    *desc = BashHash + hash;
+    unsigned     hash = hashme(operOld, operNew);
+    BashHashDsc* desc = BashHash + hash;
 
     if (desc->bhFullHash != hash)
     {
-        noway_assert(desc->bhCount == 0);   // if this ever fires, need fix the hash fn
+        noway_assert(desc->bhCount == 0); // if this ever fires, need fix the hash fn
         desc->bhFullHash = hash;
     }
 
-    desc->bhCount   += 1;
-    desc->bhOperOld  = operOld;
-    desc->bhOperNew  = operNew;
+    desc->bhCount += 1;
+    desc->bhOperOld = operOld;
+    desc->bhOperNew = operNew;
 }
 
-void                GenTree::ReportOperBashing(FILE *f)
+void GenTree::ReportOperBashing(FILE* f)
 {
-    unsigned        total = 0;
+    unsigned total = 0;
 
     fflush(f);
 
@@ -493,19 +495,16 @@ void                GenTree::ReportOperBashing(FILE *f)
 
     for (unsigned h = 0; h < BASH_HASH_SIZE; h++)
     {
-        unsigned        count = BashHash[h].bhCount;
+        unsigned count = BashHash[h].bhCount;
         if (count == 0)
             continue;
 
-        unsigned        opOld = BashHash[h].bhOperOld;
-        unsigned        opNew = BashHash[h].bhOperNew;
+        unsigned opOld = BashHash[h].bhOperOld;
+        unsigned opNew = BashHash[h].bhOperNew;
 
         fprintf(f, "    GT_%-13s -> GT_%-13s [size: %3u->%3u] %c %7u\n", OpName((genTreeOps)opOld),
-                                                                         OpName((genTreeOps)opNew),
-                                                                         s_gtTrueSizes[opOld],
-                                                                         s_gtTrueSizes[opNew],
-                                                                         (s_gtTrueSizes[opOld] < s_gtTrueSizes[opNew]) ? 'X' : ' ',
-                                                                         count);
+                OpName((genTreeOps)opNew), s_gtTrueSizes[opOld], s_gtTrueSizes[opNew],
+                (s_gtTrueSizes[opOld] < s_gtTrueSizes[opNew]) ? 'X' : ' ', count);
         total += count;
     }
     fprintf(f, "\n");
@@ -515,7 +514,7 @@ void                GenTree::ReportOperBashing(FILE *f)
     fflush(f);
 }
 
-#endif// NODEBASH_STATS
+#endif // NODEBASH_STATS
 
 #else // SMALL_TREE_NODES
 
@@ -534,7 +533,7 @@ bool GenTree::IsNodeProperlySized() const
 
 void GenTree::DumpNodeSizes(FILE* fp)
 {
-    // Dump the sizes of the various GenTree flavors
+// Dump the sizes of the various GenTree flavors
 
 #if SMALL_TREE_NODES
     fprintf(fp, "Small tree node size = %3u bytes\n", TREE_NODE_SZ_SMALL);
@@ -545,18 +544,18 @@ void GenTree::DumpNodeSizes(FILE* fp)
 #if SMALL_TREE_NODES
 
     // Verify that node sizes are set kosherly and dump sizes
-    for (unsigned op = GT_NONE+1; op < GT_COUNT; op++)
+    for (unsigned op = GT_NONE + 1; op < GT_COUNT; op++)
     {
-        unsigned    needSize = s_gtTrueSizes[op];
-        unsigned    nodeSize = s_gtNodeSizes[op];
+        unsigned needSize = s_gtTrueSizes[op];
+        unsigned nodeSize = s_gtNodeSizes[op];
 
         const char* structNm = OpStructName((genTreeOps)op);
-        const char* operName =       OpName((genTreeOps)op);
+        const char* operName = OpName((genTreeOps)op);
 
-        bool        repeated = false;
+        bool repeated = false;
 
         // Have we seen this struct flavor before?
-        for (unsigned mop = GT_NONE+1; mop < op; mop++)
+        for (unsigned mop = GT_NONE + 1; mop < op; mop++)
         {
             if (strcmp(structNm, OpStructName((genTreeOps)mop)) == 0)
             {
@@ -568,17 +567,14 @@ void GenTree::DumpNodeSizes(FILE* fp)
         // Don't repeat the same GenTree flavor unless we have an error
         if (!repeated || needSize > nodeSize)
         {
-            unsigned    sizeChar = '?';
+            unsigned sizeChar = '?';
 
-            if      (nodeSize == TREE_NODE_SZ_SMALL)
+            if (nodeSize == TREE_NODE_SZ_SMALL)
                 sizeChar = 'S';
             else if (nodeSize == TREE_NODE_SZ_LARGE)
                 sizeChar = 'L';
 
-            fprintf(fp, "GT_%-16s ... %-19s = %3u bytes (%c)", operName,
-                                                               structNm,
-                                                               needSize,
-                                                               sizeChar);
+            fprintf(fp, "GT_%-16s ... %-19s = %3u bytes (%c)", operName, structNm, needSize, sizeChar);
             if (needSize > nodeSize)
             {
                 fprintf(fp, " -- ERROR -- allocation is only %u bytes!", nodeSize);
@@ -593,7 +589,6 @@ void GenTree::DumpNodeSizes(FILE* fp)
     }
 
 #endif
-
 }
 
 #endif // MEASURE_NODE_SIZE
@@ -1946,9 +1941,10 @@ void GenTreeCall::ReplaceCallOperand(GenTree** useEdge, GenTree* replacement)
     assert(TryGetUse(*useEdge, &useEdge));
 
     GenTree* originalOperand = *useEdge;
-    *useEdge = replacement;
+    *useEdge                 = replacement;
 
-    const bool isArgument = (replacement != gtControlExpr) &&
+    const bool isArgument =
+        (replacement != gtControlExpr) &&
         ((gtCallType != CT_INDIRECT) || ((replacement != gtCallCookie) && (replacement != gtCallAddr)));
 
     if (isArgument)
@@ -2295,7 +2291,9 @@ AGAIN:
 
 #ifdef FEATURE_READYTORUN_COMPILER
                 if (op1->gtCall.gtEntryPoint.addr != op2->gtCall.gtEntryPoint.addr)
+                {
                     return false;
+                }
 #endif
             }
             else
@@ -2784,8 +2782,8 @@ AGAIN:
                     hash = genTreeHashAdd(hash, tree->gtAllocObj.gtNewHelper);
                     break;
                 case GT_OBJ:
-                    hash = genTreeHashAdd(hash, static_cast<unsigned>(
-                                                    reinterpret_cast<uintptr_t>(tree->gtObj.gtClass)));
+                    hash =
+                        genTreeHashAdd(hash, static_cast<unsigned>(reinterpret_cast<uintptr_t>(tree->gtObj.gtClass)));
                     break;
 
                 // For the ones below no extra argument matters for comparison.
@@ -3423,7 +3421,7 @@ GenTreePtr Compiler::gtReverseCond(GenTree* tree)
     else if (tree->OperGet() == GT_JCC)
     {
         GenTreeJumpCC* jcc = tree->AsJumpCC();
-        jcc->gtCondition = GenTree::ReverseRelop(jcc->gtCondition);
+        jcc->gtCondition   = GenTree::ReverseRelop(jcc->gtCondition);
     }
     else
     {
@@ -3486,24 +3484,24 @@ bool GenTree::gtIsValid64RsltMul()
 
 #endif // DEBUG
 
- //------------------------------------------------------------------------------
- // gtSetListOrder : Figure out the evaluation order for a list of values.
- //
- //
- // Arguments:
- //    list  - List to figure out the evaluation order for
- //    isListCallArgs - True iff the list is a list of call arguments
- //    callArgsInRegs -  True iff the list is a list of call arguments and they are passed in registers
- //
- // Return Value:
- //    True if the operation can be a root of a bitwise rotation tree; false otherwise.
-
-unsigned            Compiler::gtSetListOrder(GenTree *list, bool isListCallArgs, bool callArgsInRegs)
+//------------------------------------------------------------------------------
+// gtSetListOrder : Figure out the evaluation order for a list of values.
+//
+//
+// Arguments:
+//    list  - List to figure out the evaluation order for
+//    isListCallArgs - True iff the list is a list of call arguments
+//    callArgsInRegs -  True iff the list is a list of call arguments and they are passed in registers
+//
+// Return Value:
+//    True if the operation can be a root of a bitwise rotation tree; false otherwise.
+
+unsigned Compiler::gtSetListOrder(GenTree* list, bool isListCallArgs, bool callArgsInRegs)
 {
     assert((list != nullptr) && list->OperIsAnyList());
     assert(!callArgsInRegs || isListCallArgs);
 
-    ArrayStack<GenTree *> listNodes(this);
+    ArrayStack<GenTree*> listNodes(this);
 
     do
     {
@@ -3511,27 +3509,27 @@ unsigned            Compiler::gtSetListOrder(GenTree *list, bool isListCallArgs,
         list = list->gtOp.gtOp2;
     } while ((list != nullptr) && (list->OperIsAnyList()));
 
-    unsigned  nxtlvl = (list == nullptr) ? 0 : gtSetEvalOrder(list);
+    unsigned nxtlvl = (list == nullptr) ? 0 : gtSetEvalOrder(list);
     while (listNodes.Height() > 0)
     {
 #if FEATURE_STACK_FP_X87
         /* Save the current FP stack level since an argument list
         * will implicitly pop the FP stack when pushing the argument */
-        unsigned        FPlvlSave = codeGen->genGetFPstkLevel();
+        unsigned FPlvlSave = codeGen->genGetFPstkLevel();
 #endif // FEATURE_STACK_FP_X87
 
         list = listNodes.Pop();
         assert(list && list->OperIsAnyList());
-        GenTreePtr      next = list->gtOp.gtOp2;
+        GenTreePtr next = list->gtOp.gtOp2;
 
-        unsigned        level = 0;
-        unsigned        ftreg = 0;
+        unsigned level = 0;
+        unsigned ftreg = 0;
 
         // TODO: Do we have to compute costs differently for argument lists and
         // all other lists?
         // https://github.com/dotnet/coreclr/issues/7095
-        unsigned        costSz = (isListCallArgs || (next == nullptr)) ? 0 : 1;
-        unsigned        costEx = (isListCallArgs || (next == nullptr)) ? 0 : 1;
+        unsigned costSz = (isListCallArgs || (next == nullptr)) ? 0 : 1;
+        unsigned costEx = (isListCallArgs || (next == nullptr)) ? 0 : 1;
 
         if (next != nullptr)
         {
@@ -3547,8 +3545,8 @@ unsigned            Compiler::gtSetListOrder(GenTree *list, bool isListCallArgs,
             costSz += next->gtCostSz;
         }
 
-        GenTreePtr      op1 = list->gtOp.gtOp1;
-        unsigned        lvl = gtSetEvalOrder(op1);
+        GenTreePtr op1 = list->gtOp.gtOp1;
+        unsigned   lvl = gtSetEvalOrder(op1);
 
 #if FEATURE_STACK_FP_X87
         // restore the FP level
@@ -3562,8 +3560,8 @@ unsigned            Compiler::gtSetListOrder(GenTree *list, bool isListCallArgs,
         {
             unsigned tmpl;
 
-            tmpl = lvl;
-            lvl = nxtlvl;
+            tmpl   = lvl;
+            lvl    = nxtlvl;
             nxtlvl = tmpl;
         }
 
@@ -3603,7 +3601,7 @@ unsigned            Compiler::gtSetListOrder(GenTree *list, bool isListCallArgs,
         {
             costSz += op1->gtCostSz;
 #ifdef _TARGET_XARCH_
-            if (callArgsInRegs)                // push is smaller than mov to reg
+            if (callArgsInRegs) // push is smaller than mov to reg
 #endif
             {
                 costSz += 1;
@@ -4962,11 +4960,11 @@ unsigned Compiler::gtSetEvalOrder(GenTree* tree)
 
             case GT_LIST:
             case GT_FIELD_LIST:
-                {
-                    const bool isListCallArgs = false;
-                    const bool callArgsInRegs = false;
-                    return gtSetListOrder(tree, isListCallArgs, callArgsInRegs);
-                }
+            {
+                const bool isListCallArgs = false;
+                const bool callArgsInRegs = false;
+                return gtSetListOrder(tree, isListCallArgs, callArgsInRegs);
+            }
 
             default:
                 break;
@@ -5423,7 +5421,7 @@ unsigned Compiler::gtSetEvalOrder(GenTree* tree)
 #endif // FEATURE_STACK_FP_X87
                 const bool isListCallArgs = true;
                 const bool callArgsInRegs = false;
-                lvl2 = gtSetListOrder(tree->gtCall.gtCallArgs, isListCallArgs, callArgsInRegs);
+                lvl2                      = gtSetListOrder(tree->gtCall.gtCallArgs, isListCallArgs, callArgsInRegs);
                 if (level < lvl2)
                 {
                     level = lvl2;
@@ -5447,7 +5445,7 @@ unsigned Compiler::gtSetEvalOrder(GenTree* tree)
 #endif // FEATURE_STACK_FP_X87
                 const bool isListCallArgs = true;
                 const bool callArgsInRegs = true;
-                lvl2 = gtSetListOrder(tree->gtCall.gtCallLateArgs, isListCallArgs, callArgsInRegs);
+                lvl2                      = gtSetListOrder(tree->gtCall.gtCallLateArgs, isListCallArgs, callArgsInRegs);
                 if (level < lvl2)
                 {
                     level = lvl2;
@@ -7287,7 +7285,10 @@ GenTree* Compiler::gtNewBlockVal(GenTreePtr addr, unsigned size)
 //               if FEATURE_SIMD is enabled and the source has a SIMD type.
 //  isVolatile - Is this marked as volatile memory?
 
-GenTree* Compiler::gtNewCpObjNode(GenTreePtr dstAddr, GenTreePtr srcAddr, CORINFO_CLASS_HANDLE structHnd, bool isVolatile)
+GenTree* Compiler::gtNewCpObjNode(GenTreePtr           dstAddr,
+                                  GenTreePtr           srcAddr,
+                                  CORINFO_CLASS_HANDLE structHnd,
+                                  bool                 isVolatile)
 {
     GenTreePtr lhs = gtNewStructVal(structHnd, dstAddr);
     GenTree*   src = nullptr;
@@ -7881,14 +7882,15 @@ GenTreePtr Compiler::gtCloneExpr(GenTree* tree,
 
             case GT_LIST:
                 assert((tree->gtOp.gtOp2 == nullptr) || tree->gtOp.gtOp2->OperIsList());
-                copy = new (this, GT_LIST) GenTreeArgList(tree->gtOp.gtOp1);
+                copy             = new (this, GT_LIST) GenTreeArgList(tree->gtOp.gtOp1);
                 copy->gtOp.gtOp2 = tree->gtOp.gtOp2;
                 break;
 
             case GT_FIELD_LIST:
-                copy = new (this, GT_FIELD_LIST) GenTreeFieldList(tree->gtOp.gtOp1, tree->AsFieldList()->gtFieldOffset, tree->AsFieldList()->gtFieldType, nullptr);
+                copy = new (this, GT_FIELD_LIST) GenTreeFieldList(tree->gtOp.gtOp1, tree->AsFieldList()->gtFieldOffset,
+                                                                  tree->AsFieldList()->gtFieldType, nullptr);
                 copy->gtOp.gtOp2 = tree->gtOp.gtOp2;
-                copy->gtFlags = (copy->gtFlags & ~GTF_FIELD_LIST_HEAD) | (tree->gtFlags & GTF_FIELD_LIST_HEAD);
+                copy->gtFlags    = (copy->gtFlags & ~GTF_FIELD_LIST_HEAD) | (tree->gtFlags & GTF_FIELD_LIST_HEAD);
                 break;
 
             case GT_INDEX:
@@ -9057,19 +9059,12 @@ GenTreePtr GenTree::GetChild(unsigned childNum)
     }
 }
 
-GenTreeUseEdgeIterator::GenTreeUseEdgeIterator()
-    : m_node(nullptr)
-    , m_edge(nullptr)
-    , m_argList(nullptr)
-    , m_state(-1)
+GenTreeUseEdgeIterator::GenTreeUseEdgeIterator() : m_node(nullptr), m_edge(nullptr), m_argList(nullptr), m_state(-1)
 {
 }
 
 GenTreeUseEdgeIterator::GenTreeUseEdgeIterator(GenTree* node)
-    : m_node(node)
-    , m_edge(nullptr)
-    , m_argList(nullptr)
-    , m_state(0)
+    : m_node(node), m_edge(nullptr), m_argList(nullptr), m_state(0)
 {
     assert(m_node != nullptr);
 
@@ -9269,13 +9264,13 @@ void GenTreeUseEdgeIterator::MoveToNextCallUseEdge()
 {
     enum
     {
-        CALL_INSTANCE = 0,
-        CALL_ARGS = 1,
-        CALL_LATE_ARGS = 2,
+        CALL_INSTANCE     = 0,
+        CALL_ARGS         = 1,
+        CALL_LATE_ARGS    = 2,
         CALL_CONTROL_EXPR = 3,
-        CALL_COOKIE = 4,
-        CALL_ADDRESS = 5,
-        CALL_TERMINAL = 6,
+        CALL_COOKIE       = 4,
+        CALL_ADDRESS      = 5,
+        CALL_TERMINAL     = 6,
     };
 
     GenTreeCall* call = m_node->AsCall();
@@ -11225,7 +11220,8 @@ void Compiler::gtDispTree(GenTreePtr   tree,
         }
         else if (tree->OperIsFieldList())
         {
-            printf(" %s at offset %d", varTypeName(tree->AsFieldList()->gtFieldType), tree->AsFieldList()->gtFieldOffset);
+            printf(" %s at offset %d", varTypeName(tree->AsFieldList()->gtFieldType),
+                   tree->AsFieldList()->gtFieldOffset);
         }
 
         IndirectAssignmentAnnotation* pIndirAnnote;
@@ -11847,8 +11843,8 @@ void Compiler::gtDispLIRNode(GenTree* node)
     }
 
     // Visit operands
-    IndentInfo operandArc         = IIArcTop;
-    int        callArgNumber      = 0;
+    IndentInfo operandArc    = IIArcTop;
+    int        callArgNumber = 0;
     for (GenTree* operand : node->Operands())
     {
         if (operand->IsArgPlaceHolderNode() || !operand->IsValue())
@@ -12816,7 +12812,8 @@ GenTreePtr Compiler::gtFoldExprConst(GenTreePtr tree)
                         if (d1 <= -1.0 && varTypeIsUnsigned(tree->CastToType()))
                         {
                             // Don't fold conversions of these cases becasue the result is unspecified per ECMA spec
-                            // and the native math doing the fold doesn't match the run-time computation on all platforms.
+                            // and the native math doing the fold doesn't match the run-time computation on all
+                            // platforms.
                             // We want the behavior to be same with or without folding.
                             return tree;
                         }
diff --git a/src/jit/gentree.h b/src/jit/gentree.h
index 6d50cf435c..bad017c6db 100644
--- a/src/jit/gentree.h
+++ b/src/jit/gentree.h
@@ -1516,7 +1516,7 @@ public:
 
     bool OperIsAnyList() const
     {
-        return OperIsAnyList(gtOper); 
+        return OperIsAnyList(gtOper);
     }
 
     inline GenTreePtr MoveNext();
@@ -1594,7 +1594,7 @@ public:
 
     static bool Compare(GenTreePtr op1, GenTreePtr op2, bool swapOK = false);
 
-    //---------------------------------------------------------------------
+//---------------------------------------------------------------------
 
 #if defined(DEBUG)
     static const char* NodeName(genTreeOps op);
@@ -1645,10 +1645,14 @@ public:
 #if SMALL_TREE_NODES
 #if NODEBASH_STATS
     static void RecordOperBashing(genTreeOps operOld, genTreeOps operNew);
-    static void ReportOperBashing(FILE *fp);
+    static void ReportOperBashing(FILE* fp);
 #else
-    static void RecordOperBashing(genTreeOps operOld, genTreeOps operNew) { /* do nothing */ }
-    static void ReportOperBashing(FILE *fp)                               { /* do nothing */ }
+    static void RecordOperBashing(genTreeOps operOld, genTreeOps operNew)
+    { /* do nothing */
+    }
+    static void ReportOperBashing(FILE* fp)
+    { /* do nothing */
+    }
 #endif
 #endif
 
@@ -2760,7 +2764,7 @@ struct GenTreeFieldList : public GenTreeArgList
         // While GT_FIELD_LIST can be in a GT_LIST, GT_FIELD_LISTs cannot be nested or have GT_LISTs.
         assert(!arg->OperIsAnyList());
         gtFieldOffset = fieldOffset;
-        gtFieldType = fieldType;
+        gtFieldType   = fieldType;
         if (prevList == nullptr)
         {
             gtFlags |= GTF_FIELD_LIST_HEAD;
@@ -4751,21 +4755,18 @@ struct GenTreeAllocObj final : public GenTreeUnOp
 #endif
 };
 
-
 struct GenTreeJumpCC final : public GenTree
 {
     genTreeOps gtCondition; // any relop
 
     GenTreeJumpCC(genTreeOps condition)
-        : GenTree(GT_JCC, TYP_VOID DEBUGARG(/*largeNode*/ FALSE))
-        , gtCondition(condition)
+        : GenTree(GT_JCC, TYP_VOID DEBUGARG(/*largeNode*/ FALSE)), gtCondition(condition)
     {
         assert(OperIsCompare(condition));
     }
 
 #if DEBUGGABLE_GENTREE
-    GenTreeJumpCC()
-        : GenTree()
+    GenTreeJumpCC() : GenTree()
     {
     }
 #endif // DEBUGGABLE_GENTREE
diff --git a/src/jit/gschecks.cpp b/src/jit/gschecks.cpp
index 43cbb892e9..9255d8fd36 100644
--- a/src/jit/gschecks.cpp
+++ b/src/jit/gschecks.cpp
@@ -40,9 +40,9 @@ const unsigned NO_SHADOW_COPY = UINT_MAX;
  * The current function has an unsafe buffer on the stack.  Search for vulnerable
  * parameters which could be used to modify a code address and take over the process
  * in the case of a buffer overrun. Create a safe local copy for each vulnerable parameter,
- * which will be allocated bellow the unsafe buffer.  Change uses of the param to the 
+ * which will be allocated bellow the unsafe buffer.  Change uses of the param to the
  * shadow copy.
- * 
+ *
  * A pointer under indirection is considered vulnerable. A malicious user could read from
  * protected memory or write to it. If a parameter is assigned/computed into another variable,
  * and is a pointer (i.e., under indirection), then we consider the variable to be part of the
@@ -58,7 +58,7 @@ void Compiler::gsCopyShadowParams()
     // Allocate array for shadow param info
     gsShadowVarInfo = new (this, CMK_Unknown) ShadowParamVarInfo[lvaCount]();
 
-    // Find groups of variables assigned to each other, and also 
+    // Find groups of variables assigned to each other, and also
     // tracks variables which are dereferenced and marks them as ptrs.
     // Look for assignments to *p, and ptrs passed to functions
     if (gsFindVulnerableParams())
@@ -83,7 +83,7 @@ struct MarkPtrsInfo
     {
         printf(
             "[MarkPtrsInfo] = {comp = %p, lvAssignDef = %d, isAssignSrc = %d, isUnderIndir = %d, skipNextNode = %d}\n",
-                                  comp, lvAssignDef, isAssignSrc, isUnderIndir, skipNextNode);
+            comp, lvAssignDef, isAssignSrc, isUnderIndir, skipNextNode);
     }
 #endif
 };
@@ -129,7 +129,7 @@ Compiler::fgWalkResult Compiler::gsMarkPtrsAndAssignGroups(GenTreePtr* pTree, fg
             newState.isUnderIndir = true;
             {
                 newState.skipNextNode = true; // Don't have to worry about which kind of node we're dealing with
-                comp->fgWalkTreePre(&tree, comp->gsMarkPtrsAndAssignGroups, (void *)&newState);
+                comp->fgWalkTreePre(&tree, comp->gsMarkPtrsAndAssignGroups, (void*)&newState);
             }
 
             return WALK_SKIP_SUBTREES;
@@ -160,50 +160,50 @@ Compiler::fgWalkResult Compiler::gsMarkPtrsAndAssignGroups(GenTreePtr* pTree, fg
                     {
                         shadowVarInfo[pState->lvAssignDef].assignGroup->bitVectSet(lclNum);
                     }
-            
+
                     // Point both to the same bit vector
                     shadowVarInfo[lclNum].assignGroup = shadowVarInfo[pState->lvAssignDef].assignGroup;
                 }
                 else if (shadowVarInfo[lclNum].assignGroup)
                 {
                     shadowVarInfo[lclNum].assignGroup->bitVectSet(pState->lvAssignDef);
-            
+
                     // Point both to the same bit vector
                     shadowVarInfo[pState->lvAssignDef].assignGroup = shadowVarInfo[lclNum].assignGroup;
                 }
                 else
                 {
-                        FixedBitVect* bv = FixedBitVect::bitVectInit(pState->comp->lvaCount, pState->comp);
+                    FixedBitVect* bv = FixedBitVect::bitVectInit(pState->comp->lvaCount, pState->comp);
 
                     // (shadowVarInfo[pState->lvAssignDef] == NULL && shadowVarInfo[lclNew] == NULL);
                     // Neither of them has an assign group yet.  Make a new one.
                     shadowVarInfo[pState->lvAssignDef].assignGroup = bv;
-                        shadowVarInfo[lclNum].assignGroup              = bv;
+                    shadowVarInfo[lclNum].assignGroup              = bv;
                     bv->bitVectSet(pState->lvAssignDef);
                     bv->bitVectSet(lclNum);
                 }
             }
             return WALK_CONTINUE;
-    
+
         // Calls - Mark arg variables
         case GT_CALL:
 
             newState.isUnderIndir = false;
-                newState.isAssignSrc  = false;
+            newState.isAssignSrc  = false;
             {
                 if (tree->gtCall.gtCallObjp)
                 {
                     newState.isUnderIndir = true;
-                        comp->fgWalkTreePre(&tree->gtCall.gtCallObjp, gsMarkPtrsAndAssignGroups, (void*)&newState);
+                    comp->fgWalkTreePre(&tree->gtCall.gtCallObjp, gsMarkPtrsAndAssignGroups, (void*)&newState);
                 }
 
                 for (GenTreeArgList* args = tree->gtCall.gtCallArgs; args; args = args->Rest())
                 {
-                        comp->fgWalkTreePre(&args->Current(), gsMarkPtrsAndAssignGroups, (void*)&newState);
+                    comp->fgWalkTreePre(&args->Current(), gsMarkPtrsAndAssignGroups, (void*)&newState);
                 }
                 for (GenTreeArgList* args = tree->gtCall.gtCallLateArgs; args; args = args->Rest())
                 {
-                        comp->fgWalkTreePre(&args->Current(), gsMarkPtrsAndAssignGroups, (void*)&newState);
+                    comp->fgWalkTreePre(&args->Current(), gsMarkPtrsAndAssignGroups, (void*)&newState);
                 }
 
                 if (tree->gtCall.gtCallType == CT_INDIRECT)
@@ -213,7 +213,7 @@ Compiler::fgWalkResult Compiler::gsMarkPtrsAndAssignGroups(GenTreePtr* pTree, fg
                     // A function pointer is treated like a write-through pointer since
                     // it controls what code gets executed, and so indirectly can cause
                     // a write to memory.
-                        comp->fgWalkTreePre(&tree->gtCall.gtCallAddr, gsMarkPtrsAndAssignGroups, (void*)&newState);
+                    comp->fgWalkTreePre(&tree->gtCall.gtCallAddr, gsMarkPtrsAndAssignGroups, (void*)&newState);
                 }
             }
             return WALK_SKIP_SUBTREES;
@@ -223,7 +223,7 @@ Compiler::fgWalkResult Compiler::gsMarkPtrsAndAssignGroups(GenTreePtr* pTree, fg
             // We'll assume p in "**p = " can be vulnerable because by changing 'p', someone
             // could control where **p stores to.
             {
-                    comp->fgWalkTreePre(&tree->gtOp.gtOp1, comp->gsMarkPtrsAndAssignGroups, (void*)&newState);
+                comp->fgWalkTreePre(&tree->gtOp.gtOp1, comp->gsMarkPtrsAndAssignGroups, (void*)&newState);
             }
             return WALK_SKIP_SUBTREES;
 
@@ -251,7 +251,7 @@ Compiler::fgWalkResult Compiler::gsMarkPtrsAndAssignGroups(GenTreePtr* pTree, fg
                 {
                     // Walk dst side
                     comp->fgWalkTreePre(&tree->gtOp.gtOp1, comp->gsMarkPtrsAndAssignGroups, (void*)&newState);
-            
+
                     // Now handle src side
                     isLocVar = tree->gtOp.gtOp1->OperGet() == GT_LCL_VAR;
                     isLocFld = tree->gtOp.gtOp1->OperGet() == GT_LCL_FLD;
@@ -262,7 +262,7 @@ Compiler::fgWalkResult Compiler::gsMarkPtrsAndAssignGroups(GenTreePtr* pTree, fg
                         newState.lvAssignDef = lclNum;
                         newState.isAssignSrc = true;
                     }
-    
+
                     comp->fgWalkTreePre(&tree->gtOp.gtOp2, comp->gsMarkPtrsAndAssignGroups, (void*)&newState);
                 }
 
@@ -377,7 +377,7 @@ bool Compiler::gsFindVulnerableParams()
  */
 void Compiler::gsParamsToShadows()
 {
-    // Cache old count since we'll add new variables, and  
+    // Cache old count since we'll add new variables, and
     // gsShadowVarInfo will not grow to accomodate the new ones.
     UINT lvaOldCount = lvaCount;
 
@@ -513,7 +513,7 @@ void Compiler::gsParamsToShadows()
 
                 GenTreePtr src = gtNewLclvNode(shadowVar, lvaTable[shadowVar].TypeGet());
                 GenTreePtr dst = gtNewLclvNode(lclNum, varDsc->TypeGet());
-                
+
                 src->gtFlags |= GTF_DONT_CSE;
                 dst->gtFlags |= GTF_DONT_CSE;
 
@@ -530,7 +530,7 @@ void Compiler::gsParamsToShadows()
                 {
                     opAssign = gtNewAssignNode(dst, src);
                 }
-                
+
                 (void)fgInsertStmtNearEnd(block, fgMorphTree(opAssign));
             }
         }
@@ -552,8 +552,8 @@ Compiler::fgWalkResult Compiler::gsReplaceShadowParams(GenTreePtr* pTree, fgWalk
     {
         asg  = tree;             // "asg" is the assignment tree.
         tree = tree->gtOp.gtOp1; // "tree" is the local var tree at the left-hand size of the assignment.
-    }        
-    
+    }
+
     if (tree->gtOper == GT_LCL_VAR || tree->gtOper == GT_LCL_FLD)
     {
         UINT paramNum = tree->gtLclVarCommon.gtLclNum;
@@ -571,7 +571,7 @@ Compiler::fgWalkResult Compiler::gsReplaceShadowParams(GenTreePtr* pTree, fgWalk
         if (varTypeIsSmall(comp->lvaTable[paramNum].TypeGet()))
         {
             tree->gtType = TYP_INT;
-            if (asg) 
+            if (asg)
             {
                 // If this is an assignment tree, propagate the type to it as well.
                 asg->gtType = TYP_INT;
diff --git a/src/jit/importer.cpp b/src/jit/importer.cpp
index 001a529315..b80d06417b 100644
--- a/src/jit/importer.cpp
+++ b/src/jit/importer.cpp
@@ -1777,15 +1777,19 @@ GenTreePtr Compiler::impReadyToRunLookupToTree(CORINFO_CONST_LOOKUP* pLookup,
                                                unsigned              handleFlags,
                                                void*                 compileTimeHandle)
 {
-    CORINFO_GENERIC_HANDLE handle       = 0;
-    void*                  pIndirection = 0;
+    CORINFO_GENERIC_HANDLE handle       = nullptr;
+    void*                  pIndirection = nullptr;
     assert(pLookup->accessType != IAT_PPVALUE);
 
     if (pLookup->accessType == IAT_VALUE)
+    {
         handle = pLookup->handle;
+    }
     else if (pLookup->accessType == IAT_PVALUE)
+    {
         pIndirection = pLookup->addr;
-    return gtNewIconEmbHndNode(handle, pIndirection, handleFlags, 0, 0, compileTimeHandle);
+    }
+    return gtNewIconEmbHndNode(handle, pIndirection, handleFlags, 0, nullptr, compileTimeHandle);
 }
 
 GenTreePtr Compiler::impReadyToRunHelperToTree(
@@ -1798,7 +1802,9 @@ GenTreePtr Compiler::impReadyToRunHelperToTree(
     CORINFO_CONST_LOOKUP lookup;
 #if COR_JIT_EE_VERSION > 460
     if (!info.compCompHnd->getReadyToRunHelper(pResolvedToken, pGenericLookupKind, helper, &lookup))
-        return NULL;
+    {
+        return nullptr;
+    }
 #else
     info.compCompHnd->getReadyToRunHelper(pResolvedToken, helper, &lookup);
 #endif
@@ -1828,7 +1834,9 @@ GenTreePtr Compiler::impMethodPointer(CORINFO_RESOLVED_TOKEN* pResolvedToken, CO
                 *op1->gtFptrVal.gtLdftnResolvedToken = *pResolvedToken;
             }
             else
+            {
                 op1->gtFptrVal.gtEntryPoint.addr = nullptr;
+            }
 #endif
             break;
 
@@ -5001,7 +5009,7 @@ void Compiler::impImportAndPushBox(CORINFO_RESOLVED_TOKEN* pResolvedToken)
         if (opts.IsReadyToRun())
         {
             op1                   = impReadyToRunHelperToTree(pResolvedToken, CORINFO_HELP_READYTORUN_NEW, TYP_REF);
-            usingReadyToRunHelper = (op1 != NULL);
+            usingReadyToRunHelper = (op1 != nullptr);
         }
 
         if (!usingReadyToRunHelper)
@@ -7035,7 +7043,7 @@ var_types Compiler::impImportCall(OPCODE                  opcode,
                 {
                     instParam =
                         impReadyToRunLookupToTree(&callInfo->instParamLookup, GTF_ICON_CLASS_HDL, exactClassHandle);
-                    if (instParam == NULL)
+                    if (instParam == nullptr)
                     {
                         return callRetTyp;
                     }
@@ -12403,7 +12411,7 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                         if (opts.IsReadyToRun())
                         {
                             op1 = impReadyToRunHelperToTree(&resolvedToken, CORINFO_HELP_READYTORUN_NEW, TYP_REF);
-                            usingReadyToRunHelper = (op1 != NULL);
+                            usingReadyToRunHelper = (op1 != nullptr);
                         }
 
                         if (!usingReadyToRunHelper)
@@ -12832,7 +12840,9 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
 #ifdef FEATURE_READYTORUN_COMPILER
                         if (fieldInfo.fieldAccessor == CORINFO_FIELD_INSTANCE_WITH_BASE)
+                        {
                             op1->gtField.gtFieldLookup = fieldInfo.fieldLookup;
+                        }
 #endif
 
                         op1->gtFlags |= (obj->gtFlags & GTF_GLOB_EFFECT);
@@ -13138,7 +13148,9 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
 #ifdef FEATURE_READYTORUN_COMPILER
                         if (fieldInfo.fieldAccessor == CORINFO_FIELD_INSTANCE_WITH_BASE)
+                        {
                             op1->gtField.gtFieldLookup = fieldInfo.fieldLookup;
+                        }
 #endif
 
                         op1->gtFlags |= (obj->gtFlags & GTF_GLOB_EFFECT);
@@ -13380,7 +13392,7 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 {
                     op1 = impReadyToRunHelperToTree(&resolvedToken, CORINFO_HELP_READYTORUN_NEWARR_1, TYP_REF,
                                                     gtNewArgList(op2));
-                    usingReadyToRunHelper = (op1 != NULL);
+                    usingReadyToRunHelper = (op1 != nullptr);
 
                     if (!usingReadyToRunHelper)
                     {
@@ -13392,9 +13404,11 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                         // Reason: performance (today, we'll always use the slow helper for the R2R generics case)
 
                         // Need to restore array classes before creating array objects on the heap
-                        op1 = impTokenToHandle(&resolvedToken, NULL, TRUE /*mustRestoreHandle*/);
-                        if (op1 == NULL) // compDonotInline()
+                        op1 = impTokenToHandle(&resolvedToken, nullptr, TRUE /*mustRestoreHandle*/);
+                        if (op1 == nullptr)
+                        { // compDonotInline()
                             return;
+                        }
                     }
                 }
 
@@ -13502,7 +13516,7 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     GenTreePtr opLookup =
                         impReadyToRunHelperToTree(&resolvedToken, CORINFO_HELP_READYTORUN_ISINSTANCEOF, TYP_REF,
                                                   gtNewArgList(op1));
-                    usingReadyToRunHelper = (opLookup != NULL);
+                    usingReadyToRunHelper = (opLookup != nullptr);
                     op1                   = (usingReadyToRunHelper ? opLookup : op1);
 
                     if (!usingReadyToRunHelper)
@@ -13514,9 +13528,11 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                         //      3) Perform the 'is instance' check on the input object
                         // Reason: performance (today, we'll always use the slow helper for the R2R generics case)
 
-                        op2 = impTokenToHandle(&resolvedToken, NULL, FALSE);
-                        if (op2 == NULL) // compDonotInline()
+                        op2 = impTokenToHandle(&resolvedToken, nullptr, FALSE);
+                        if (op2 == nullptr)
+                        { // compDonotInline()
                             return;
+                        }
                     }
                 }
 
@@ -14030,7 +14046,7 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 {
                     GenTreePtr opLookup = impReadyToRunHelperToTree(&resolvedToken, CORINFO_HELP_READYTORUN_CHKCAST,
                                                                     TYP_REF, gtNewArgList(op1));
-                    usingReadyToRunHelper = (opLookup != NULL);
+                    usingReadyToRunHelper = (opLookup != nullptr);
                     op1                   = (usingReadyToRunHelper ? opLookup : op1);
 
                     if (!usingReadyToRunHelper)
@@ -14042,9 +14058,11 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                         //      3) Check the object on the stack for the type-cast
                         // Reason: performance (today, we'll always use the slow helper for the R2R generics case)
 
-                        op2 = impTokenToHandle(&resolvedToken, NULL, FALSE);
-                        if (op2 == NULL) // compDonotInline()
+                        op2 = impTokenToHandle(&resolvedToken, nullptr, FALSE);
+                        if (op2 == nullptr)
+                        { // compDonotInline()
                             return;
+                        }
                     }
                 }
 
diff --git a/src/jit/jit.h b/src/jit/jit.h
index 7485b8b388..10a0adaee7 100644
--- a/src/jit/jit.h
+++ b/src/jit/jit.h
@@ -259,7 +259,7 @@ struct CLRConfig
 #define FEATURE_UNIX_AMD64_STRUCT_PASSING_ONLY(x)
 #endif // defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
 
-#if defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)|| (defined(_TARGET_X86_) && !defined(LEGACY_BACKEND))
+#if defined(FEATURE_UNIX_AMD64_STRUCT_PASSING) || (defined(_TARGET_X86_) && !defined(LEGACY_BACKEND))
 #define FEATURE_PUT_STRUCT_ARG_STK 1
 #define PUT_STRUCT_ARG_STK_ONLY_ARG(x) , x
 #define PUT_STRUCT_ARG_STK_ONLY(x) x
@@ -477,15 +477,15 @@ typedef ptrdiff_t ssize_t;
 #define NODEBASH_STATS 0      // Collect stats on changed gtOper values in GenTree's.
 #define COUNT_AST_OPERS 0     // Display use counts for GenTree operators.
 
-#define VERBOSE_SIZES 0       // Always display GC info sizes. If set, DISPLAY_SIZES must also be set.
-#define VERBOSE_VERIFY 0      // Dump additional information when verifying code. Useful to debug verification bugs.
+#define VERBOSE_SIZES 0  // Always display GC info sizes. If set, DISPLAY_SIZES must also be set.
+#define VERBOSE_VERIFY 0 // Dump additional information when verifying code. Useful to debug verification bugs.
 
 #ifdef DEBUG
-#define MEASURE_MEM_ALLOC 1   // Collect memory allocation stats.
-#define LOOP_HOIST_STATS 1    // Collect loop hoisting stats.
+#define MEASURE_MEM_ALLOC 1 // Collect memory allocation stats.
+#define LOOP_HOIST_STATS 1  // Collect loop hoisting stats.
 #else
-#define MEASURE_MEM_ALLOC 0   // You can set this to 1 to get memory stats in retail, as well
-#define LOOP_HOIST_STATS 0    // You can set this to 1 to get loop hoist stats in retail, as well
+#define MEASURE_MEM_ALLOC 0 // You can set this to 1 to get memory stats in retail, as well
+#define LOOP_HOIST_STATS 0  // You can set this to 1 to get loop hoist stats in retail, as well
 #endif
 
 /*****************************************************************************/
diff --git a/src/jit/jitconfigvalues.h b/src/jit/jitconfigvalues.h
index d03a31f305..954e863504 100644
--- a/src/jit/jitconfigvalues.h
+++ b/src/jit/jitconfigvalues.h
@@ -215,7 +215,7 @@ CONFIG_INTEGER(JitEnableNoWayAssert, W("JitEnableNoWayAssert"), 1)
 // (normally MEASURE_MEM_ALLOC is off for release builds but if it's toggled on
 // for release in "jit.h" the flag would be missing for some includers).
 // TODO-Cleanup: need to make 'MEASURE_MEM_ALLOC' well-defined here at all times.
-CONFIG_INTEGER(DisplayMemStats, W("JitMemStats"), 0)             // Display JIT memory usage statistics
+CONFIG_INTEGER(DisplayMemStats, W("JitMemStats"), 0) // Display JIT memory usage statistics
 
 CONFIG_INTEGER(JitAggressiveInlining, W("JitAggressiveInlining"), 0) // Aggressive inlining of all methods
 CONFIG_INTEGER(JitELTHookEnabled, W("JitELTHookEnabled"), 0) // On ARM, setting this will emit Enter/Leave/TailCall
diff --git a/src/jit/lclvars.cpp b/src/jit/lclvars.cpp
index 31e982b78d..e0ebc6a6dd 100644
--- a/src/jit/lclvars.cpp
+++ b/src/jit/lclvars.cpp
@@ -1448,13 +1448,13 @@ void Compiler::lvaCanPromoteStructType(CORINFO_CLASS_HANDLE    typeHnd,
 
 #if 1 // TODO-Cleanup: Consider removing this entire #if block in the future
 
-        // This method has two callers. The one in Importer.cpp passes sortFields == false
-        // and the other passes sortFields == true.
-        // This is a workaround that leaves the inlining behavior the same as before while still
-        // performing extra struct promotions when compiling the method.
-        //
-        // The x86 legacy back-end can't handle the more general RyuJIT struct promotion (notably structs
-        // with holes), in genPushArgList(), so in that case always check for custom layout.
+// This method has two callers. The one in Importer.cpp passes sortFields == false
+// and the other passes sortFields == true.
+// This is a workaround that leaves the inlining behavior the same as before while still
+// performing extra struct promotions when compiling the method.
+//
+// The x86 legacy back-end can't handle the more general RyuJIT struct promotion (notably structs
+// with holes), in genPushArgList(), so in that case always check for custom layout.
 #if FEATURE_FIXED_OUT_ARGS || !defined(LEGACY_BACKEND)
         if (!sortFields) // the condition "!sortFields" really means "we are inlining"
 #endif
diff --git a/src/jit/lir.cpp b/src/jit/lir.cpp
index 22a2f1c00d..bc9111eb32 100644
--- a/src/jit/lir.cpp
+++ b/src/jit/lir.cpp
@@ -679,7 +679,7 @@ void LIR::Range::FinishInsertBefore(GenTree* insertionPoint, GenTree* first, Gen
             assert(m_lastNode != nullptr);
             assert(m_lastNode->gtNext == nullptr);
             m_lastNode->gtNext = first;
-            first->gtPrev = m_lastNode;
+            first->gtPrev      = m_lastNode;
         }
         m_lastNode = last;
     }
@@ -867,7 +867,7 @@ void LIR::Range::FinishInsertAfter(GenTree* insertionPoint, GenTree* first, GenT
             assert(m_firstNode != nullptr);
             assert(m_firstNode->gtPrev == nullptr);
             m_firstNode->gtPrev = last;
-            last->gtNext = m_firstNode;
+            last->gtNext        = m_firstNode;
         }
         m_firstNode = first;
     }
@@ -1158,7 +1158,6 @@ void LIR::Range::Delete(Compiler* compiler, BasicBlock* block, ReadOnlyRange&& r
     Delete(compiler, block, range.m_firstNode, range.m_lastNode);
 }
 
-
 //------------------------------------------------------------------------
 // LIR::Range::TryGetUse: Try to find the use for a given node.
 //
@@ -1617,22 +1616,21 @@ void LIR::InsertBeforeTerminator(BasicBlock* block, LIR::Range&& range)
 #if DEBUG
         switch (block->bbJumpKind)
         {
-        case BBJ_COND:
-            assert(insertionPoint->OperIsConditionalJump());
-            break;
+            case BBJ_COND:
+                assert(insertionPoint->OperIsConditionalJump());
+                break;
 
-        case BBJ_SWITCH:
-            assert((insertionPoint->OperGet() == GT_SWITCH) || (insertionPoint->OperGet() == GT_SWITCH_TABLE));
-            break;
+            case BBJ_SWITCH:
+                assert((insertionPoint->OperGet() == GT_SWITCH) || (insertionPoint->OperGet() == GT_SWITCH_TABLE));
+                break;
 
-        case BBJ_RETURN:
-            assert((insertionPoint->OperGet() == GT_RETURN) ||
-                (insertionPoint->OperGet() == GT_JMP) ||
-                (insertionPoint->OperGet() == GT_CALL));
-            break;
+            case BBJ_RETURN:
+                assert((insertionPoint->OperGet() == GT_RETURN) || (insertionPoint->OperGet() == GT_JMP) ||
+                       (insertionPoint->OperGet() == GT_CALL));
+                break;
 
-        default:
-            unreached();
+            default:
+                unreached();
         }
 #endif
     }
diff --git a/src/jit/liveness.cpp b/src/jit/liveness.cpp
index a8c674f51d..67f1ba21f6 100644
--- a/src/jit/liveness.cpp
+++ b/src/jit/liveness.cpp
@@ -1113,7 +1113,7 @@ void Compiler::fgExtendDbgLifetimes()
                 // Create initialization node
                 if (!block->IsLIR())
                 {
-                    GenTree* varNode = gtNewLclvNode(varNum, type);
+                    GenTree* varNode  = gtNewLclvNode(varNum, type);
                     GenTree* initNode = gtNewAssignNode(varNode, zero);
 
                     // Create a statement for the initializer, sequence it, and append it to the current BB.
@@ -1124,7 +1124,8 @@ void Compiler::fgExtendDbgLifetimes()
                 }
                 else
                 {
-                    GenTree* store = new (this, GT_STORE_LCL_VAR) GenTreeLclVar(GT_STORE_LCL_VAR, type, varNum, BAD_IL_OFFSET);
+                    GenTree* store =
+                        new (this, GT_STORE_LCL_VAR) GenTreeLclVar(GT_STORE_LCL_VAR, type, varNum, BAD_IL_OFFSET);
                     store->gtOp.gtOp1 = zero;
                     store->gtFlags |= (GTF_VAR_DEF | GTF_ASG);
 
diff --git a/src/jit/lower.cpp b/src/jit/lower.cpp
index f21073d287..1b21855c33 100644
--- a/src/jit/lower.cpp
+++ b/src/jit/lower.cpp
@@ -238,7 +238,7 @@ GenTree* Lowering::LowerNode(GenTree* node)
 #if FEATURE_MULTIREG_RET
                 GenTree* src = node->gtGetOp1();
                 assert((src->OperGet() == GT_CALL) && src->AsCall()->HasMultiRegRetVal());
-#else // !FEATURE_MULTIREG_RET
+#else  // !FEATURE_MULTIREG_RET
                 assert(!"Unexpected struct local store in Lowering");
 #endif // !FEATURE_MULTIREG_RET
             }
@@ -917,19 +917,17 @@ GenTreePtr Lowering::NewPutArg(GenTreeCall* call, GenTreePtr arg, fgArgTabEntryP
         // instead of in out-going arg area slot.
 
         PUT_STRUCT_ARG_STK_ONLY(assert(info->isStruct == varTypeIsStruct(type))); // Make sure state is
-                                                                                                 // correct
+                                                                                  // correct
 
 #if FEATURE_FASTTAILCALL
         putArg = new (comp, GT_PUTARG_STK)
-            GenTreePutArgStk(GT_PUTARG_STK, type, arg,
-                             info->slotNum PUT_STRUCT_ARG_STK_ONLY_ARG(info->numSlots)
-                                 PUT_STRUCT_ARG_STK_ONLY_ARG(info->isStruct),
+            GenTreePutArgStk(GT_PUTARG_STK, type, arg, info->slotNum PUT_STRUCT_ARG_STK_ONLY_ARG(info->numSlots)
+                                                           PUT_STRUCT_ARG_STK_ONLY_ARG(info->isStruct),
                              call->IsFastTailCall() DEBUGARG(call));
 #else
         putArg = new (comp, GT_PUTARG_STK)
-            GenTreePutArgStk(GT_PUTARG_STK, type, arg,
-                             info->slotNum PUT_STRUCT_ARG_STK_ONLY_ARG(info->numSlots)
-                                 PUT_STRUCT_ARG_STK_ONLY_ARG(info->isStruct) DEBUGARG(call));
+            GenTreePutArgStk(GT_PUTARG_STK, type, arg, info->slotNum PUT_STRUCT_ARG_STK_ONLY_ARG(info->numSlots)
+                                                           PUT_STRUCT_ARG_STK_ONLY_ARG(info->isStruct) DEBUGARG(call));
 #endif
 
 #ifdef FEATURE_PUT_STRUCT_ARG_STK
@@ -1730,8 +1728,8 @@ GenTree* Lowering::LowerTailCallViaHelper(GenTreeCall* call, GenTree* callTarget
     assert(!comp->compLocallocUsed);                         // tail call from methods that also do localloc
 
 #ifdef _TARGET_AMD64_
-    assert(!comp->getNeedsGSSecurityCookie());               // jit64 compat: tail calls from methods that need GS check
-#endif // _TARGET_AMD64_
+    assert(!comp->getNeedsGSSecurityCookie()); // jit64 compat: tail calls from methods that need GS check
+#endif                                         // _TARGET_AMD64_
 
     // We expect to see a call that meets the following conditions
     assert(call->IsTailCallViaHelper());
@@ -1950,7 +1948,7 @@ void Lowering::LowerCompare(GenTree* cmp)
     }
 
     LIR::Use cmpUse;
-    
+
     if (!BlockRange().TryGetUse(cmp, &cmpUse) || cmpUse.User()->OperGet() != GT_JTRUE)
     {
         return;
@@ -1967,7 +1965,7 @@ void Lowering::LowerCompare(GenTree* cmp)
     {
         loSrc1.ReplaceWithLclVar(comp, weight);
     }
-    
+
     if (loSrc2.Def()->OperGet() != GT_CNS_INT && loSrc2.Def()->OperGet() != GT_LCL_VAR)
     {
         loSrc2.ReplaceWithLclVar(comp, weight);
@@ -2007,8 +2005,8 @@ void Lowering::LowerCompare(GenTree* cmp)
 
         BlockRange().Remove(loSrc1.Def());
         BlockRange().Remove(loSrc2.Def());
-        GenTree* loCmp = comp->gtNewOperNode(cmp->OperGet(), TYP_INT, loSrc1.Def(), loSrc2.Def());
-        loCmp->gtFlags = cmp->gtFlags;
+        GenTree* loCmp   = comp->gtNewOperNode(cmp->OperGet(), TYP_INT, loSrc1.Def(), loSrc2.Def());
+        loCmp->gtFlags   = cmp->gtFlags;
         GenTree* loJtrue = comp->gtNewOperNode(GT_JTRUE, TYP_VOID, loCmp);
         LIR::AsRange(newBlock).InsertAfter(nullptr, loSrc1.Def(), loSrc2.Def(), loCmp, loJtrue);
 
@@ -2065,31 +2063,31 @@ void Lowering::LowerCompare(GenTree* cmp)
 
         genTreeOps hiCmpOper;
         genTreeOps loCmpOper;
-        
+
         switch (cmp->OperGet())
         {
-        case GT_LT:
-            cmp->gtOper = GT_GT;
-            hiCmpOper   = GT_LT;
-            loCmpOper   = GT_LT;
-            break;
-        case GT_LE:
-            cmp->gtOper = GT_GT;
-            hiCmpOper   = GT_LT;
-            loCmpOper   = GT_LE;
-            break;
-        case GT_GT:
-            cmp->gtOper = GT_LT;
-            hiCmpOper   = GT_GT;
-            loCmpOper   = GT_GT;
-            break;
-        case GT_GE:
-            cmp->gtOper = GT_LT;
-            hiCmpOper   = GT_GT;
-            loCmpOper   = GT_GE;
-            break;
-        default:
-            unreached();
+            case GT_LT:
+                cmp->gtOper = GT_GT;
+                hiCmpOper   = GT_LT;
+                loCmpOper   = GT_LT;
+                break;
+            case GT_LE:
+                cmp->gtOper = GT_GT;
+                hiCmpOper   = GT_LT;
+                loCmpOper   = GT_LE;
+                break;
+            case GT_GT:
+                cmp->gtOper = GT_LT;
+                hiCmpOper   = GT_GT;
+                loCmpOper   = GT_GT;
+                break;
+            case GT_GE:
+                cmp->gtOper = GT_LT;
+                hiCmpOper   = GT_GT;
+                loCmpOper   = GT_GE;
+                break;
+            default:
+                unreached();
         }
 
         BasicBlock* newBlock2 = comp->fgSplitBlockAtEnd(newBlock);
@@ -2100,8 +2098,8 @@ void Lowering::LowerCompare(GenTree* cmp)
 
         BlockRange().Remove(loSrc1.Def());
         BlockRange().Remove(loSrc2.Def());
-        GenTree* loCmp = comp->gtNewOperNode(loCmpOper, TYP_INT, loSrc1.Def(), loSrc2.Def());
-        loCmp->gtFlags = cmp->gtFlags | GTF_UNSIGNED;
+        GenTree* loCmp   = comp->gtNewOperNode(loCmpOper, TYP_INT, loSrc1.Def(), loSrc2.Def());
+        loCmp->gtFlags   = cmp->gtFlags | GTF_UNSIGNED;
         GenTree* loJtrue = comp->gtNewOperNode(GT_JTRUE, TYP_VOID, loCmp);
         LIR::AsRange(newBlock2).InsertAfter(nullptr, loSrc1.Def(), loSrc2.Def(), loCmp, loJtrue);
 
@@ -3195,7 +3193,7 @@ GenTree* Lowering::LowerVirtualStubCall(GenTreeCall* call)
 // So we don't use a register.
 #ifndef _TARGET_X86_
             // on x64 we must materialize the target using specific registers.
-            addr->gtRegNum  = REG_VIRTUAL_STUB_PARAM;
+            addr->gtRegNum = REG_VIRTUAL_STUB_PARAM;
 
             indir->gtRegNum = REG_JUMP_THUNK_PARAM;
             indir->gtFlags |= GTF_IND_VSD_TGT;
@@ -3479,12 +3477,12 @@ void Lowering::LowerUnsignedDivOrMod(GenTree* node)
 {
     assert((node->OperGet() == GT_UDIV) || (node->OperGet() == GT_UMOD));
 
-    GenTree* divisor = node->gtGetOp2();
+    GenTree* divisor  = node->gtGetOp2();
     GenTree* dividend = node->gtGetOp1();
 
     if (divisor->IsCnsIntOrI()
 #ifdef _TARGET_X86_
-            && (dividend->OperGet() != GT_LONG)
+        && (dividend->OperGet() != GT_LONG)
 #endif
             )
     {
@@ -4054,16 +4052,16 @@ void Lowering::CheckCallArg(GenTree* arg)
 #endif
 
         case GT_FIELD_LIST:
-            {
-                GenTreeFieldList* list = arg->AsFieldList();
-                assert(list->IsFieldListHead());
+        {
+            GenTreeFieldList* list = arg->AsFieldList();
+            assert(list->IsFieldListHead());
 
-                for (; list != nullptr; list = list->Rest())
-                {
-                    assert(list->Current()->OperIsPutArg());
-                }
+            for (; list != nullptr; list = list->Rest())
+            {
+                assert(list->Current()->OperIsPutArg());
             }
-            break;
+        }
+        break;
 
         default:
             assert(arg->OperIsPutArg());
diff --git a/src/jit/lowerarm64.cpp b/src/jit/lowerarm64.cpp
index 7c6164f963..c16da58e0d 100644
--- a/src/jit/lowerarm64.cpp
+++ b/src/jit/lowerarm64.cpp
@@ -1306,9 +1306,9 @@ void Lowering::TreeNodeInfoInitBlockStore(GenTreeBlk* blkNode)
     {
         // CopyObj or CopyBlk
         // Sources are src and dest and size if not constant.
-        unsigned   size              = blkNode->gtBlkSize;
-        GenTreePtr source            = blkNode->Data();
-        GenTree*   srcAddr           = nullptr;
+        unsigned   size    = blkNode->gtBlkSize;
+        GenTreePtr source  = blkNode->Data();
+        GenTree*   srcAddr = nullptr;
 
         if (source->gtOper == GT_IND)
         {
diff --git a/src/jit/lowerxarch.cpp b/src/jit/lowerxarch.cpp
index 5d6fc0a603..fb459e57fd 100644
--- a/src/jit/lowerxarch.cpp
+++ b/src/jit/lowerxarch.cpp
@@ -1048,17 +1048,17 @@ void Lowering::TreeNodeInfoInitShiftRotate(GenTree* tree)
 
         if (tree->OperGet() == GT_LSH_HI)
         {
-            GenTreePtr sourceLo = source->gtOp.gtOp1;
+            GenTreePtr sourceLo              = source->gtOp.gtOp1;
             sourceLo->gtLsraInfo.isDelayFree = true;
         }
         else
         {
-            GenTreePtr sourceHi = source->gtOp.gtOp2;
+            GenTreePtr sourceHi              = source->gtOp.gtOp2;
             sourceHi->gtLsraInfo.isDelayFree = true;
         }
 
         source->gtLsraInfo.hasDelayFreeSrc = true;
-        info->hasDelayFreeSrc = true;
+        info->hasDelayFreeSrc              = true;
     }
 #endif
 
@@ -1160,7 +1160,7 @@ void Lowering::TreeNodeInfoInitCall(GenTreeCall* call)
             }
             else
 #endif // _TARGET_X86_
-            if (ctrlExpr->isIndir())
+                if (ctrlExpr->isIndir())
             {
                 MakeSrcContained(call, ctrlExpr);
             }
@@ -1333,7 +1333,7 @@ void Lowering::TreeNodeInfoInitCall(GenTreeCall* call)
 
                 // There could be up to 2 PUTARG_REGs in the list
                 GenTreeFieldList* fieldListPtr = argNode->AsFieldList();
-                unsigned        iterationNum   = 0;
+                unsigned          iterationNum = 0;
                 for (; fieldListPtr; fieldListPtr = fieldListPtr->Rest())
                 {
                     GenTreePtr putArgRegNode = fieldListPtr->Current();
@@ -1911,7 +1911,7 @@ void Lowering::TreeNodeInfoInitPutArgStk(GenTree* tree)
 #ifdef _TARGET_X86_
     if (tree->gtOp.gtOp1->gtOper == GT_FIELD_LIST)
     {
-        GenTreeFieldList* fieldListPtr   = tree->gtOp.gtOp1->AsFieldList();
+        GenTreeFieldList* fieldListPtr = tree->gtOp.gtOp1->AsFieldList();
         for (; fieldListPtr; fieldListPtr = fieldListPtr->Rest())
         {
             GenTree* fieldNode = fieldListPtr->Current();
@@ -2005,7 +2005,7 @@ void Lowering::TreeNodeInfoInitPutArgStk(GenTree* tree)
 
 #ifdef _TARGET_X86_
         if (size >= 8)
-#else // !_TARGET_X86_
+#else  // !_TARGET_X86_
         if (size >= XMM_REGSIZE_BYTES)
 #endif // !_TARGET_X86_
         {
@@ -2289,7 +2289,7 @@ void Lowering::TreeNodeInfoInitModDiv(GenTree* tree)
         // To avoid reg move would like to have op1's low part in RAX and high part in RDX.
         GenTree* loVal = op1->gtGetOp1();
         GenTree* hiVal = op1->gtGetOp2();
-        
+
         // Src count is actually 3, so increment.
         assert(op2->IsCnsIntOrI());
         info->srcCount++;
@@ -2884,8 +2884,8 @@ void Lowering::SetIndirAddrOpCounts(GenTreePtr indirTree)
         assert(base != addr);
         m_lsra->clearOperandCounts(addr);
 
-        const bool hasBase   = base != nullptr;
-        const bool hasIndex  = index != nullptr;
+        const bool hasBase  = base != nullptr;
+        const bool hasIndex = index != nullptr;
         assert(hasBase || hasIndex); // At least one of a base or an index must be present.
 
         // If the addressing mode has both a base and an index, bump its source count by one. If it only has one or the
@@ -2905,7 +2905,7 @@ void Lowering::SetIndirAddrOpCounts(GenTreePtr indirTree)
 
         bool foundBase  = !hasBase;
         bool foundIndex = !hasIndex;
-        for (GenTree* child = addr, *nextChild = nullptr; child != nullptr && !child->OperIsLeaf(); child = nextChild)
+        for (GenTree *child = addr, *nextChild = nullptr; child != nullptr && !child->OperIsLeaf(); child = nextChild)
         {
             nextChild    = nullptr;
             GenTree* op1 = child->gtOp.gtOp1;
@@ -3330,8 +3330,9 @@ void Lowering::TreeNodeInfoInitCmp(GenTreePtr tree)
 #ifdef DEBUG
                         if (comp->verbose)
                         {
-                            printf("TreeNodeInfoInitCmp: Removing a GT_CAST to TYP_UBYTE and changing castOp1->gtType to "
-                                   "TYP_UBYTE\n");
+                            printf(
+                                "TreeNodeInfoInitCmp: Removing a GT_CAST to TYP_UBYTE and changing castOp1->gtType to "
+                                "TYP_UBYTE\n");
                             comp->gtDispTreeRange(BlockRange(), tree);
                         }
 #endif
@@ -3358,9 +3359,9 @@ void Lowering::TreeNodeInfoInitCmp(GenTreePtr tree)
         }
         else if (op1->IsCnsIntOrI())
         {
-			// TODO-CQ: We should be able to support swapping op1 and op2 to generate cmp reg, imm,
-			// but there is currently an assert in CodeGen::genCompareInt().
-			// https://github.com/dotnet/coreclr/issues/7270
+            // TODO-CQ: We should be able to support swapping op1 and op2 to generate cmp reg, imm,
+            // but there is currently an assert in CodeGen::genCompareInt().
+            // https://github.com/dotnet/coreclr/issues/7270
             SetRegOptional(op2);
         }
         else
@@ -3893,14 +3894,14 @@ void Lowering::SetMulOpCounts(GenTreePtr tree)
     GenTreeIntConCommon* imm                    = nullptr;
     GenTreePtr           other                  = nullptr;
 
-    // There are three forms of x86 multiply:
-    // one-op form:     RDX:RAX = RAX * r/m
-    // two-op form:     reg *= r/m
-    // three-op form:   reg = r/m * imm
+// There are three forms of x86 multiply:
+// one-op form:     RDX:RAX = RAX * r/m
+// two-op form:     reg *= r/m
+// three-op form:   reg = r/m * imm
 
-    // This special widening 32x32->64 MUL is not used on x64
+// This special widening 32x32->64 MUL is not used on x64
 #if defined(_TARGET_X86_)
-    if(tree->OperGet() != GT_MUL_LONG)
+    if (tree->OperGet() != GT_MUL_LONG)
 #endif
     {
         assert((tree->gtFlags & GTF_MUL_64RSLT) == 0);
@@ -3924,9 +3925,9 @@ void Lowering::SetMulOpCounts(GenTreePtr tree)
     }
     else if (tree->gtOper == GT_MULHI
 #if defined(_TARGET_X86_)
-            || tree->OperGet() == GT_MUL_LONG
+             || tree->OperGet() == GT_MUL_LONG
 #endif
-            )
+             )
     {
         // have to use the encoding:RDX:RAX = RAX * rm
         info->setDstCandidates(m_lsra, RBM_RAX);
diff --git a/src/jit/lsra.cpp b/src/jit/lsra.cpp
index fa774b4196..3b477ca12d 100644
--- a/src/jit/lsra.cpp
+++ b/src/jit/lsra.cpp
@@ -358,12 +358,12 @@ RegRecord* LinearScan::getRegisterRecord(regNumber regNum)
 
 //----------------------------------------------------------------------------
 // getConstrainedRegMask: Returns new regMask which is the intersection of
-// regMaskActual and regMaskConstraint if the new regMask has at least 
+// regMaskActual and regMaskConstraint if the new regMask has at least
 // minRegCount registers, otherwise returns regMaskActual.
 //
 // Arguments:
 //     regMaskActual      -  regMask that needs to be constrained
-//     regMaskConstraint  -  regMask constraint that needs to be 
+//     regMaskConstraint  -  regMask constraint that needs to be
 //                           applied to regMaskActual
 //     minRegCount        -  Minimum number of regs that should be
 //                           be present in new regMask.
@@ -371,9 +371,7 @@ RegRecord* LinearScan::getRegisterRecord(regNumber regNum)
 // Return Value:
 //     New regMask that has minRegCount registers after instersection.
 //     Otherwise returns regMaskActual.
-regMaskTP LinearScan::getConstrainedRegMask(regMaskTP regMaskActual, 
-                                            regMaskTP regMaskConstraint, 
-                                            unsigned minRegCount)
+regMaskTP LinearScan::getConstrainedRegMask(regMaskTP regMaskActual, regMaskTP regMaskConstraint, unsigned minRegCount)
 {
     regMaskTP newMask = regMaskActual & regMaskConstraint;
     if (genCountBits(newMask) >= minRegCount)
@@ -402,42 +400,33 @@ regMaskTP LinearScan::stressLimitRegs(RefPosition* refPosition, regMaskTP mask)
 {
     if (getStressLimitRegs() != LSRA_LIMIT_NONE)
     {
-        // The refPosition could be null, for example when called 
+        // The refPosition could be null, for example when called
         // by getTempRegForResolution().
-        int minRegCount = (refPosition != nullptr) ?
-                          refPosition->minRegCandidateCount : 1;
+        int minRegCount = (refPosition != nullptr) ? refPosition->minRegCandidateCount : 1;
 
         switch (getStressLimitRegs())
         {
             case LSRA_LIMIT_CALLEE:
                 if (!compiler->opts.compDbgEnC)
                 {
-                    mask = getConstrainedRegMask(mask, 
-                                                 RBM_CALLEE_SAVED, 
-                                                 minRegCount);
+                    mask = getConstrainedRegMask(mask, RBM_CALLEE_SAVED, minRegCount);
                 }
                 break;
 
             case LSRA_LIMIT_CALLER:
-                {
-                    mask = getConstrainedRegMask(mask,
-                                                 RBM_CALLEE_TRASH,
-                                                 minRegCount);
-                }
-                break;
+            {
+                mask = getConstrainedRegMask(mask, RBM_CALLEE_TRASH, minRegCount);
+            }
+            break;
 
             case LSRA_LIMIT_SMALL_SET:
                 if ((mask & LsraLimitSmallIntSet) != RBM_NONE)
                 {
-                    mask = getConstrainedRegMask(mask,
-                                                 LsraLimitSmallIntSet,
-                                                 minRegCount);
+                    mask = getConstrainedRegMask(mask, LsraLimitSmallIntSet, minRegCount);
                 }
                 else if ((mask & LsraLimitSmallFPSet) != RBM_NONE)
                 {
-                    mask = getConstrainedRegMask(mask,
-                                                 LsraLimitSmallFPSet,
-                                                 minRegCount);
+                    mask = getConstrainedRegMask(mask, LsraLimitSmallFPSet, minRegCount);
                 }
                 break;
 
@@ -709,9 +698,8 @@ void LinearScan::applyCalleeSaveHeuristics(RefPosition* rp)
     regMaskTP calleeSaveMask = calleeSaveRegs(getRegisterType(theInterval, rp));
     if (doReverseCallerCallee())
     {
-        rp->registerAssignment = getConstrainedRegMask(rp->registerAssignment, 
-                                                       calleeSaveMask, 
-                                                       rp->minRegCandidateCount);
+        rp->registerAssignment =
+            getConstrainedRegMask(rp->registerAssignment, calleeSaveMask, rp->minRegCandidateCount);
     }
     else
 #endif // DEBUG
@@ -2826,30 +2814,23 @@ bool LinearScan::buildKillPositionsForNode(GenTree* tree, LsraLocation currentLo
 
 //----------------------------------------------------------------------------
 // defineNewInternalTemp: Defines a ref position for an internal temp.
-// 
+//
 // Arguments:
 //     tree                  -   Gentree node requiring an internal register
 //     regType               -   Register type
 //     currentLoc            -   Location of the temp Def position
 //     regMask               -   register mask of candidates for temp
 //     minRegCandidateCount  -   Minimum registers to be ensured in candidate
-//                               set under LSRA stress mode.  This is a 
+//                               set under LSRA stress mode.  This is a
 //                               DEBUG only arg.
 RefPosition* LinearScan::defineNewInternalTemp(GenTree*     tree,
                                                RegisterType regType,
                                                LsraLocation currentLoc,
-                                               regMaskTP    regMask
-                                               DEBUGARG(unsigned minRegCandidateCount))
+                                               regMaskTP regMask DEBUGARG(unsigned minRegCandidateCount))
 {
     Interval* current   = newInterval(regType);
     current->isInternal = true;
-    return newRefPosition(current, 
-                          currentLoc, 
-                          RefTypeDef, 
-                          tree, 
-                          regMask, 
-                          0 
-                          DEBUG_ARG(minRegCandidateCount));
+    return newRefPosition(current, currentLoc, RefTypeDef, tree, regMask, 0 DEBUG_ARG(minRegCandidateCount));
 }
 
 //------------------------------------------------------------------------
@@ -2894,16 +2875,16 @@ int LinearScan::buildInternalRegisterDefsForNode(GenTree*     tree,
             internalIntCands = genFindLowestBit(internalIntCands);
             internalCands &= ~internalIntCands;
         }
-        temps[count] = defineNewInternalTemp(tree, IntRegisterType, currentLoc, 
-                                             internalIntCands DEBUG_ARG(minRegCandidateCount));
+        temps[count] =
+            defineNewInternalTemp(tree, IntRegisterType, currentLoc, internalIntCands DEBUG_ARG(minRegCandidateCount));
     }
 
     int internalFloatCount = tree->gtLsraInfo.internalFloatCount;
     for (int i = 0; i < internalFloatCount; i++)
     {
         regMaskTP internalFPCands = (internalCands & internalFloatRegCandidates());
-        temps[count++]            = defineNewInternalTemp(tree, FloatRegisterType, currentLoc, 
-                                                          internalFPCands DEBUG_ARG(minRegCandidateCount));
+        temps[count++] =
+            defineNewInternalTemp(tree, FloatRegisterType, currentLoc, internalFPCands DEBUG_ARG(minRegCandidateCount));
     }
 
     noway_assert(count < MaxInternalRegisters);
@@ -2918,7 +2899,7 @@ int LinearScan::buildInternalRegisterDefsForNode(GenTree*     tree,
 // Arguments:
 //   tree                  -   Gentree node that needs internal registers
 //   currentLoc            -   Location at which Use positions need to be defined
-//   defs                  -   int array containing Def positions of internal 
+//   defs                  -   int array containing Def positions of internal
 //                             registers.
 //   total                 -   Total number of Def positions in 'defs' array.
 //   minRegCandidateCount  -   Minimum registers to be ensured in candidate
@@ -2930,8 +2911,7 @@ int LinearScan::buildInternalRegisterDefsForNode(GenTree*     tree,
 void LinearScan::buildInternalRegisterUsesForNode(GenTree*     tree,
                                                   LsraLocation currentLoc,
                                                   RefPosition* defs[],
-                                                  int          total
-                                                  DEBUGARG(unsigned minRegCandidateCount))
+                                                  int total DEBUGARG(unsigned minRegCandidateCount))
 {
     assert(total < MaxInternalRegisters);
 
@@ -2948,14 +2928,9 @@ void LinearScan::buildInternalRegisterUsesForNode(GenTree*     tree,
         }
         else
         {
-            RefPosition* newest = newRefPosition(defs[i]->getInterval(), 
-                                                 currentLoc, 
-                                                 RefTypeUse, 
-                                                 tree, 
-                                                 mask, 
-                                                 0
-                                                 DEBUG_ARG(minRegCandidateCount));
-            newest->lastUse     = true;
+            RefPosition* newest = newRefPosition(defs[i]->getInterval(), currentLoc, RefTypeUse, tree, mask,
+                                                 0 DEBUG_ARG(minRegCandidateCount));
+            newest->lastUse = true;
         }
     }
 }
@@ -3525,7 +3500,7 @@ void LinearScan::buildRefPositionsForNode(GenTree*                  tree,
             {
                 // Get the location info for the register defined by the first operand.
                 LocationInfoList operandDefs;
-                bool found = operandToLocationInfoMap.TryGetValue(*(tree->OperandsBegin()), &operandDefs);
+                bool             found = operandToLocationInfoMap.TryGetValue(*(tree->OperandsBegin()), &operandDefs);
                 assert(found);
 
                 // Since we only expect to consume one register, we should only have a single register to
@@ -3646,18 +3621,12 @@ void LinearScan::buildRefPositionsForNode(GenTree*                  tree,
     // consume + produce + internalCount.  This is the minimum
     // set of registers that needs to be ensured in candidate
     // set of ref positions created.
-    unsigned minRegCount = consume +
-                           produce +
-                           info.internalIntCount +
-                           info.internalFloatCount;
-#endif //DEBUG
+    unsigned minRegCount = consume + produce + info.internalIntCount + info.internalFloatCount;
+#endif // DEBUG
 
     // make intervals for all the 'internal' register requirements for this node
     // where internal means additional registers required temporarily
-    int internalCount = buildInternalRegisterDefsForNode(tree, 
-                                                         currentLoc, 
-                                                         internalRefs
-                                                         DEBUG_ARG(minRegCount));
+    int internalCount = buildInternalRegisterDefsForNode(tree, currentLoc, internalRefs DEBUG_ARG(minRegCount));
 
     // pop all ref'd tree temps
     GenTreeOperandIterator iterator = tree->OperandsBegin();
@@ -3775,9 +3744,9 @@ void LinearScan::buildRefPositionsForNode(GenTree*                  tree,
         // of GT_DIV node.
         //
         // Assume further JitStressRegs=2, which would constrain
-        // candidates to callee trashable regs { eax, ecx, edx } on 
+        // candidates to callee trashable regs { eax, ecx, edx } on
         // use positions of v01 and v02.  LSRA allocates ecx for v01.
-        // Use position of v02 cannot be allocated a regs since it 
+        // Use position of v02 cannot be allocated a regs since it
         // is marked delay-reg free and {eax,edx} are getting killed
         // before the def of GT_DIV.  For this reason, minRegCount
         // for Use position of v02 also needs to take into account
@@ -3790,10 +3759,10 @@ void LinearScan::buildRefPositionsForNode(GenTree*                  tree,
             {
                 minRegCountForUsePos += genCountBits(killMask);
             }
-        }       
+        }
 #endif // DEBUG
 
-        RefPosition* pos;        
+        RefPosition* pos;
         if ((candidates & allRegs(i->registerType)) == 0)
         {
             // This should only occur where we've got a type mismatch due to SIMD
@@ -3806,13 +3775,13 @@ void LinearScan::buildRefPositionsForNode(GenTree*                  tree,
                 regNumber    physicalReg = genRegNumFromMask(fixedAssignment);
                 RefPosition* pos = newRefPosition(physicalReg, currentLoc, RefTypeFixedReg, nullptr, fixedAssignment);
             }
-            pos = newRefPosition(i, currentLoc, RefTypeUse, useNode, allRegs(i->registerType), 
-                                 multiRegIdx  DEBUG_ARG(minRegCountForUsePos));
+            pos = newRefPosition(i, currentLoc, RefTypeUse, useNode, allRegs(i->registerType),
+                                 multiRegIdx DEBUG_ARG(minRegCountForUsePos));
             pos->registerAssignment = candidates;
         }
         else
         {
-            pos = newRefPosition(i, currentLoc, RefTypeUse, useNode, candidates, 
+            pos = newRefPosition(i, currentLoc, RefTypeUse, useNode, candidates,
                                  multiRegIdx DEBUG_ARG(minRegCountForUsePos));
         }
 
@@ -3839,8 +3808,7 @@ void LinearScan::buildRefPositionsForNode(GenTree*                  tree,
         listNodePool.ReturnNodes(operandDefs);
     }
 
-    buildInternalRegisterUsesForNode(tree, currentLoc, internalRefs, 
-                                     internalCount DEBUG_ARG(minRegCount));
+    buildInternalRegisterUsesForNode(tree, currentLoc, internalRefs, internalCount DEBUG_ARG(minRegCount));
 
     RegisterType registerType  = getDefType(tree);
     regMaskTP    candidates    = getDefCandidates(tree);
@@ -3944,8 +3912,8 @@ void LinearScan::buildRefPositionsForNode(GenTree*                  tree,
             locationInfoList.Append(listNodePool.GetNode(defLocation, interval, tree, (unsigned)i));
         }
 
-        RefPosition* pos = newRefPosition(interval, defLocation, defRefType, defNode, 
-                                          currCandidates, (unsigned)i DEBUG_ARG(minRegCount));
+        RefPosition* pos = newRefPosition(interval, defLocation, defRefType, defNode, currCandidates,
+                                          (unsigned)i DEBUG_ARG(minRegCount));
         if (info.isLocalDefUse)
         {
             pos->isLocalDefUse = true;
@@ -3960,8 +3928,8 @@ void LinearScan::buildRefPositionsForNode(GenTree*                  tree,
     buildUpperVectorRestoreRefPositions(tree, currentLoc, liveLargeVectors);
 #endif // FEATURE_PARTIAL_SIMD_CALLEE_SAVE
 
-    bool isContainedNode =
-        !noAdd && consume == 0 && produce == 0 && (tree->OperIsFieldListHead() || ((tree->TypeGet() != TYP_VOID) && !tree->OperIsStore()));
+    bool isContainedNode = !noAdd && consume == 0 && produce == 0 &&
+                           (tree->OperIsFieldListHead() || ((tree->TypeGet() != TYP_VOID) && !tree->OperIsStore()));
     if (isContainedNode)
     {
         // Contained nodes map to the concatenated lists of their operands.
@@ -5567,7 +5535,7 @@ regNumber LinearScan::allocateBusyReg(Interval* current, RefPosition* refPositio
             // on x86 under LSRA stress.
             if (!allocateIfProfitable)
             {
-                physRegNextLocation = MaxLocation;
+                physRegNextLocation  = MaxLocation;
                 farthestRefPosWeight = BB_MAX_WEIGHT;
             }
         }
diff --git a/src/jit/lsra.h b/src/jit/lsra.h
index 54bee3024d..1b23e9a655 100644
--- a/src/jit/lsra.h
+++ b/src/jit/lsra.h
@@ -771,22 +771,19 @@ private:
     regMaskTP getDefCandidates(GenTree* tree);
     var_types getDefType(GenTree* tree);
 
-    RefPosition* defineNewInternalTemp(GenTree* tree, 
-                                       RegisterType regType, 
-                                       LsraLocation currentLoc, 
-                                       regMaskTP regMask
-                                       DEBUGARG(unsigned minRegCandidateCount));
-
-    int buildInternalRegisterDefsForNode(GenTree* tree, 
-                                         LsraLocation currentLoc, 
-                                         RefPosition* defs[]
-                                         DEBUGARG(unsigned minRegCandidateCount));
-
-    void buildInternalRegisterUsesForNode(GenTree* tree, 
-                                          LsraLocation currentLoc, 
-                                          RefPosition* defs[], 
-                                          int total
-                                          DEBUGARG(unsigned minRegCandidateCount));
+    RefPosition* defineNewInternalTemp(GenTree*     tree,
+                                       RegisterType regType,
+                                       LsraLocation currentLoc,
+                                       regMaskTP regMask DEBUGARG(unsigned minRegCandidateCount));
+
+    int buildInternalRegisterDefsForNode(GenTree*     tree,
+                                         LsraLocation currentLoc,
+                                         RefPosition* defs[] DEBUGARG(unsigned minRegCandidateCount));
+
+    void buildInternalRegisterUsesForNode(GenTree*     tree,
+                                          LsraLocation currentLoc,
+                                          RefPosition* defs[],
+                                          int total DEBUGARG(unsigned minRegCandidateCount));
 
     void resolveLocalRef(BasicBlock* block, GenTreePtr treeNode, RefPosition* currentRefPosition);
 
@@ -837,8 +834,7 @@ private:
                                 RefType      theRefType,
                                 GenTree*     theTreeNode,
                                 regMaskTP    mask,
-                                unsigned     multiRegIdx = 0
-                                DEBUGARG(unsigned minRegCandidateCount = 1));
+                                unsigned multiRegIdx = 0 DEBUGARG(unsigned minRegCandidateCount = 1));
 
     RefPosition* newRefPosition(
         regNumber reg, LsraLocation theLocation, RefType theRefType, GenTree* theTreeNode, regMaskTP mask);
@@ -950,11 +946,8 @@ private:
                               char*             operandString,
                               unsigned          operandStringLength);
     void lsraDispNode(GenTreePtr tree, LsraTupleDumpMode mode, bool hasDest);
-    void DumpOperandDefs(GenTree* operand,
-                         bool& first,
-                         LsraTupleDumpMode mode,
-                         char* operandString,
-                         const unsigned operandStringLength);
+    void DumpOperandDefs(
+        GenTree* operand, bool& first, LsraTupleDumpMode mode, char* operandString, const unsigned operandStringLength);
     void TupleStyleDump(LsraTupleDumpMode mode);
 
     bool         dumpTerse;
@@ -1395,7 +1388,7 @@ public:
         , isLocalDefUse(false)
         , delayRegFree(false)
         , outOfOrder(false)
-#ifdef DEBUG        
+#ifdef DEBUG
         , minRegCandidateCount(1)
         , rpNum(0)
 #endif
@@ -1572,13 +1565,13 @@ public:
 #ifdef DEBUG
     // Minimum number registers that needs to be ensured while
     // constraining candidates for this ref position under
-    // LSRA stress. 
+    // LSRA stress.
     unsigned minRegCandidateCount;
 
     // The unique RefPosition number, equal to its index in the
     // refPositions list. Only used for debugging dumps.
-    unsigned rpNum; 
-#endif  // DEBUG
+    unsigned rpNum;
+#endif // DEBUG
 
     bool isIntervalRef()
     {
diff --git a/src/jit/morph.cpp b/src/jit/morph.cpp
index 42fbb0775c..d1a85a1c96 100644
--- a/src/jit/morph.cpp
+++ b/src/jit/morph.cpp
@@ -2014,7 +2014,7 @@ GenTreePtr Compiler::fgMakeTmpArgNode(
 
         arg->gtFlags |= GTF_DONT_CSE;
 
-#else // !FEATURE_UNIX_AMD64_STRUCT_PASSING
+#else  // !FEATURE_UNIX_AMD64_STRUCT_PASSING
         // Can this type be passed in a single register?
         // If so, the following call will return the corresponding primitive type.
         // Otherwise, it will return TYP_UNKNOWN and we will pass by reference.
@@ -2759,18 +2759,18 @@ GenTreeCall* Compiler::fgMorphArgs(GenTreeCall* callNode)
         // so we record the stack depth on the first morph call when reMorphing
         // was false (via RecordStkLevel) and then retrieve that value here (via RetrieveStkLevel)
         //
-		unsigned callStkLevel = call->fgArgInfo->RetrieveStkLevel();
-		if (call->gtCallLateArgs != nullptr)
-		{
-			fgPtrArgCntCur += callStkLevel;
-			call->gtCallLateArgs = fgMorphTree(call->gtCallLateArgs)->AsArgList();
-			flagsSummary |= call->gtCallLateArgs->gtFlags;
-			fgPtrArgCntCur -= callStkLevel;
-		}
-		assert(call->fgArgInfo != nullptr);
-		call->fgArgInfo->RemorphReset();
-
-		numArgs = call->fgArgInfo->ArgCount();
+        unsigned callStkLevel = call->fgArgInfo->RetrieveStkLevel();
+        if (call->gtCallLateArgs != nullptr)
+        {
+            fgPtrArgCntCur += callStkLevel;
+            call->gtCallLateArgs = fgMorphTree(call->gtCallLateArgs)->AsArgList();
+            flagsSummary |= call->gtCallLateArgs->gtFlags;
+            fgPtrArgCntCur -= callStkLevel;
+        }
+        assert(call->fgArgInfo != nullptr);
+        call->fgArgInfo->RemorphReset();
+
+        numArgs = call->fgArgInfo->ArgCount();
     }
     else
     {
@@ -2807,19 +2807,20 @@ GenTreeCall* Compiler::fgMorphArgs(GenTreeCall* callNode)
         }
         // The x86 shift helpers have custom calling conventions and expect the lo part of the long to be in EAX and the
         // hi part to be in EDX. This sets the argument registers up correctly.
-        else if (call->IsHelperCall(this, CORINFO_HELP_LLSH) || call->IsHelperCall(this, CORINFO_HELP_LRSH) || call->IsHelperCall(this, CORINFO_HELP_LRSZ))
+        else if (call->IsHelperCall(this, CORINFO_HELP_LLSH) || call->IsHelperCall(this, CORINFO_HELP_LRSH) ||
+                 call->IsHelperCall(this, CORINFO_HELP_LRSZ))
         {
             GenTreeArgList* args = call->gtCallArgs;
-            GenTree* arg1 = args->Current();
+            GenTree*        arg1 = args->Current();
             assert(arg1 != nullptr);
             nonStandardArgs.Add(arg1, REG_LNGARG_LO);
 
-            args = args->Rest();
+            args          = args->Rest();
             GenTree* arg2 = args->Current();
             assert(arg2 != nullptr);
             nonStandardArgs.Add(arg2, REG_LNGARG_HI);
         }
-#else // !defined(_TARGET_X86_)
+#else  // !defined(_TARGET_X86_)
         // TODO-X86-CQ: Currently RyuJIT/x86 passes args on the stack, so this is not needed.
         // If/when we change that, the following code needs to be changed to correctly support the (TBD) managed calling
         // convention for x86/SSE.
@@ -3307,7 +3308,7 @@ GenTreeCall* Compiler::fgMorphArgs(GenTreeCall* callNode)
                     }
                 }
 #else  // !FEATURE_UNIX_AMD64_STRUCT_PASSING
-                size           = 1; // On AMD64, all primitives fit in a single (64-bit) 'slot'
+                size = 1; // On AMD64, all primitives fit in a single (64-bit) 'slot'
 #endif // FEATURE_UNIX_AMD64_STRUCT_PASSING
 #elif defined(_TARGET_ARM64_)
                 if (isStructArg)
@@ -4134,7 +4135,7 @@ GenTreeCall* Compiler::fgMorphArgs(GenTreeCall* callNode)
         }
 #endif // !LEGACY_BACKEND
 
-#if defined (_TARGET_X86_) && !defined(LEGACY_BACKEND)
+#if defined(_TARGET_X86_) && !defined(LEGACY_BACKEND)
         if (isStructArg)
         {
             GenTree* lclNode = fgIsIndirOfAddrOfLocal(argx);
@@ -4142,9 +4143,9 @@ GenTreeCall* Compiler::fgMorphArgs(GenTreeCall* callNode)
                 (lvaGetPromotionType(lclNode->AsLclVarCommon()->gtLclNum) == Compiler::PROMOTION_TYPE_INDEPENDENT))
             {
                 // Make a GT_FIELD_LIST of the field lclVars.
-                GenTreeLclVarCommon* lcl = lclNode->AsLclVarCommon();
-                LclVarDsc* varDsc = &(lvaTable[lcl->gtLclNum]);
-                GenTreeFieldList* fieldList = nullptr;
+                GenTreeLclVarCommon* lcl       = lclNode->AsLclVarCommon();
+                LclVarDsc*           varDsc    = &(lvaTable[lcl->gtLclNum]);
+                GenTreeFieldList*    fieldList = nullptr;
                 for (unsigned fieldLclNum = varDsc->lvFieldLclStart;
                      fieldLclNum < varDsc->lvFieldLclStart + varDsc->lvFieldCnt; ++fieldLclNum)
                 {
@@ -4154,15 +4155,17 @@ GenTreeCall* Compiler::fgMorphArgs(GenTreeCall* callNode)
                         lcl->SetLclNum(fieldLclNum);
                         lcl->ChangeOper(GT_LCL_VAR);
                         lcl->gtType = fieldVarDsc->lvType;
-                        fieldList = new (this, GT_FIELD_LIST) GenTreeFieldList(lcl, fieldVarDsc->lvFldOffset, fieldVarDsc->lvType, nullptr);
+                        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;
+                        args->gtOp.gtOp1    = fieldList;
                     }
                     else
                     {
                         GenTree* fieldLcl = gtNewLclvNode(fieldLclNum, fieldVarDsc->lvType);
-                        fieldList = new (this, GT_FIELD_LIST) GenTreeFieldList(fieldLcl, fieldVarDsc->lvFldOffset, fieldVarDsc->lvType, fieldList);
+                        fieldList         = new (this, GT_FIELD_LIST)
+                            GenTreeFieldList(fieldLcl, fieldVarDsc->lvFldOffset, fieldVarDsc->lvType, fieldList);
                     }
                 }
             }
@@ -4291,9 +4294,9 @@ GenTreeCall* Compiler::fgMorphArgs(GenTreeCall* callNode)
     // is added to make sure to call EvalArgsToTemp.
     if (!reMorphing && (call->fgArgInfo->HasRegArgs()
 #ifdef FEATURE_UNIX_AMD64_STRUCT_PASSING
-                              || hasStackArgCopy
+                        || hasStackArgCopy
 #endif // FEATURE_UNIX_AMD64_STRUCT_PASSING
-                              ))
+                        ))
     {
         // This is the first time that we morph this call AND it has register arguments.
         // Follow into the code below and do the 'defer or eval to temp' analysis.
@@ -4442,8 +4445,8 @@ void Compiler::fgMorphSystemVStructArgs(GenTreeCall* call, bool hasStructArgumen
                                                               fgEntryPtr->structDesc.eightByteSizes[0]);
                         GenTreeFieldList* fieldList =
                             new (this, GT_FIELD_LIST) GenTreeFieldList(arg, 0, originalType, nullptr);
-                        fieldList->gtType          = originalType; // Preserve the type. It is a special case.
-                        arg = fieldList;
+                        fieldList->gtType = originalType; // Preserve the type. It is a special case.
+                        arg               = fieldList;
 
                         // Second eightbyte.
                         GenTreeLclFld* newLclField = new (this, GT_LCL_FLD)
@@ -4453,8 +4456,8 @@ void Compiler::fgMorphSystemVStructArgs(GenTreeCall* call, bool hasStructArgumen
                                           lclCommon->gtLclNum, fgEntryPtr->structDesc.eightByteOffsets[1]);
 
                         fieldList = new (this, GT_FIELD_LIST) GenTreeFieldList(newLclField, 0, originalType, fieldList);
-                        fieldList->gtType          = originalType; // Preserve the type. It is a special case.
-                        newLclField->gtFieldSeq    = FieldSeqStore::NotAField();
+                        fieldList->gtType       = originalType; // Preserve the type. It is a special case.
+                        newLclField->gtFieldSeq = FieldSeqStore::NotAField();
                     }
                     else
                     {
@@ -4871,7 +4874,7 @@ GenTreePtr Compiler::fgMorphMultiregStructArg(GenTreePtr arg, fgArgTabEntryPtr f
                     //    with a FIELD_LIST(LCLVAR-LO, FIELD_LIST(LCLVAR-HI, nullptr))
                     //
                     newArg = new (this, GT_FIELD_LIST) GenTreeFieldList(loLclVar, 0, loType, nullptr);
-                    (void) new (this, GT_FIELD_LIST) GenTreeFieldList(hiLclVar, TARGET_POINTER_SIZE, hiType, newArg);
+                    (void)new (this, GT_FIELD_LIST) GenTreeFieldList(hiLclVar, TARGET_POINTER_SIZE, hiType, newArg);
                 }
             }
         }
@@ -4941,11 +4944,11 @@ GenTreePtr Compiler::fgMorphMultiregStructArg(GenTreePtr arg, fgArgTabEntryPtr f
             //    replace the existing LDOBJ(ADDR(LCLVAR))
             //    with a FIELD_LIST(LCLFLD-LO, FIELD_LIST(LCLFLD-HI, nullptr) ...)
             //
-            unsigned offset = 0;
+            unsigned          offset    = 0;
             GenTreeFieldList* listEntry = nullptr;
             for (unsigned inx = 0; inx < elemCount; inx++)
             {
-                elemSize = genTypeSize(type[inx]);
+                elemSize              = genTypeSize(type[inx]);
                 GenTreePtr nextLclFld = gtNewLclFldNode(varNum, type[inx], offset);
                 listEntry = new (this, GT_FIELD_LIST) GenTreeFieldList(nextLclFld, offset, type[inx], listEntry);
                 if (newArg == nullptr)
@@ -4968,11 +4971,11 @@ GenTreePtr Compiler::fgMorphMultiregStructArg(GenTreePtr arg, fgArgTabEntryPtr f
             //    with a FIELD_LIST(IND(EXPR), FIELD_LIST(IND(EXPR+8), nullptr) ...)
             //
 
-            unsigned offset = 0;
+            unsigned          offset    = 0;
             GenTreeFieldList* listEntry = nullptr;
             for (unsigned inx = 0; inx < elemCount; inx++)
             {
-                elemSize = genTypeSize(type[inx]);
+                elemSize           = genTypeSize(type[inx]);
                 GenTreePtr curAddr = baseAddr;
                 if (offset != 0)
                 {
@@ -4985,7 +4988,7 @@ GenTreePtr Compiler::fgMorphMultiregStructArg(GenTreePtr arg, fgArgTabEntryPtr f
                     curAddr = baseAddr;
                 }
                 GenTreePtr curItem = gtNewOperNode(GT_IND, type[inx], curAddr);
-                listEntry = new (this, GT_FIELD_LIST) GenTreeFieldList(curItem, offset, type[inx], listEntry);
+                listEntry          = new (this, GT_FIELD_LIST) GenTreeFieldList(curItem, offset, type[inx], listEntry);
                 if (newArg == nullptr)
                 {
                     newArg = listEntry;
@@ -5716,8 +5719,7 @@ GenTreePtr Compiler::fgMorphArrayIndex(GenTreePtr tree)
     addr = gtNewOperNode(GT_ADD, TYP_BYREF, addr, cns);
 
 #if SMALL_TREE_NODES
-    assert((tree->gtDebugFlags & GTF_DEBUG_NODE_LARGE) ||
-           GenTree::s_gtNodeSizes[GT_IND] == TREE_NODE_SZ_SMALL);
+    assert((tree->gtDebugFlags & GTF_DEBUG_NODE_LARGE) || GenTree::s_gtNodeSizes[GT_IND] == TREE_NODE_SZ_SMALL);
 #endif
 
     // Change the orginal GT_INDEX node into a GT_IND node
@@ -6248,7 +6250,9 @@ GenTreePtr Compiler::fgMorphField(GenTreePtr tree, MorphAddrContext* mac)
             GenTreePtr baseOffset = gtNewIconEmbHndNode(tree->gtField.gtFieldLookup.addr, nullptr, GTF_ICON_FIELD_HDL);
 
             if (tree->gtField.gtFieldLookup.accessType == IAT_PVALUE)
+            {
                 baseOffset = gtNewOperNode(GT_IND, TYP_I_IMPL, baseOffset);
+            }
 
             addr =
                 gtNewOperNode(GT_ADD, (var_types)(objRefType == TYP_I_IMPL ? TYP_I_IMPL : TYP_BYREF), addr, baseOffset);
diff --git a/src/jit/rationalize.cpp b/src/jit/rationalize.cpp
index 7e75354380..1a9c38aa5f 100644
--- a/src/jit/rationalize.cpp
+++ b/src/jit/rationalize.cpp
@@ -617,9 +617,8 @@ Compiler::fgWalkResult Rationalizer::RewriteNode(GenTree** useEdge, ArrayStack<G
     // First, remove any preceeding list nodes, which are not otherwise visited by the tree walk.
     //
     // NOTE: GT_FIELD_LIST head nodes, and GT_LIST nodes used by phi nodes will in fact be visited.
-    for (GenTree* prev = node->gtPrev;
-        prev != nullptr && prev->OperIsAnyList() && !(prev->OperIsFieldListHead());
-        prev = node->gtPrev)
+    for (GenTree* prev = node->gtPrev; prev != nullptr && prev->OperIsAnyList() && !(prev->OperIsFieldListHead());
+         prev          = node->gtPrev)
     {
         BlockRange().Remove(prev);
     }
diff --git a/src/jit/valuenum.h b/src/jit/valuenum.h
index 17dacfbb54..78adfd971e 100644
--- a/src/jit/valuenum.h
+++ b/src/jit/valuenum.h
@@ -450,7 +450,7 @@ public:
 
     // Get a new, unique value number for an expression that we're not equating to some function,
     // which is the value of a tree in the given block.
-    ValueNum VNForExpr(BasicBlock *block, var_types typ = TYP_UNKNOWN);
+    ValueNum VNForExpr(BasicBlock* block, var_types typ = TYP_UNKNOWN);
 
 // This controls extra tracing of the "evaluation" of "VNF_MapSelect" functions.
 #define FEATURE_VN_TRACE_APPLY_SELECTORS 1
@@ -485,13 +485,11 @@ public:
 
     ValueNumPair VNPairApplySelectors(ValueNumPair map, FieldSeqNode* fieldSeq, var_types indType);
 
-    ValueNumPair VNPairApplySelectorsAssign(ValueNumPair  map,
-                                            FieldSeqNode* fieldSeq,
-                                            ValueNumPair  rhs,
-                                            var_types     indType,
-                                            BasicBlock*   block)
+    ValueNumPair VNPairApplySelectorsAssign(
+        ValueNumPair map, FieldSeqNode* fieldSeq, ValueNumPair rhs, var_types indType, BasicBlock* block)
     {
-        return ValueNumPair(VNApplySelectorsAssign(VNK_Liberal, map.GetLiberal(), fieldSeq, rhs.GetLiberal(), indType, block),
+        return ValueNumPair(VNApplySelectorsAssign(VNK_Liberal, map.GetLiberal(), fieldSeq, rhs.GetLiberal(), indType,
+                                                   block),
                             VNApplySelectorsAssign(VNK_Conservative, map.GetConservative(), fieldSeq,
                                                    rhs.GetConservative(), indType, block));
     }
@@ -883,9 +881,14 @@ private:
         ChunkExtraAttribs      m_attribs;
         BasicBlock::loopNumber m_loopNum;
 
-        // Initialize a chunk, starting at "*baseVN", for the given "typ", "attribs", and "loopNum" (using "alloc" for allocations).
+        // Initialize a chunk, starting at "*baseVN", for the given "typ", "attribs", and "loopNum" (using "alloc" for
+        // allocations).
         // (Increments "*baseVN" by ChunkSize.)
-        Chunk(IAllocator* alloc, ValueNum* baseVN, var_types typ, ChunkExtraAttribs attribs, BasicBlock::loopNumber loopNum);
+        Chunk(IAllocator*            alloc,
+              ValueNum*              baseVN,
+              var_types              typ,
+              ChunkExtraAttribs      attribs,
+              BasicBlock::loopNumber loopNum);
 
         // Requires that "m_numUsed < ChunkSize."  Returns the offset of the allocated VN within the chunk; the
         // actual VN is this added to the "m_baseVN" of the chunk.