Clean up GTF_CALL_VIRT_KIND_MASK and related usage

BruceForstall · BruceForstall · commit a480afbd9c34 · 2017-11-22T14:05:09.000-08:00
Use the existing accessor functions instead of checking the bits directly.
diff --git a/src/jit/assertionprop.cpp b/src/jit/assertionprop.cpp
@@ -2093,7 +2093,7 @@ void Compiler::optAssertionGen(GenTreePtr tree)
         case GT_CALL:
             // A virtual call can create a non-null assertion. We transform some virtual calls into non-virtual calls
             // with a GTF_CALL_NULLCHECK flag set.
-            if ((tree->gtFlags & GTF_CALL_NULLCHECK) || ((tree->gtFlags & GTF_CALL_VIRT_KIND_MASK) != GTF_CALL_NONVIRT))
+            if ((tree->gtFlags & GTF_CALL_NULLCHECK) || tree->AsCall()->IsVirtual())
             {
                 //  Retrieve the 'this' arg
                 GenTreePtr thisArg = gtGetThisArg(tree->AsCall());
diff --git a/src/jit/codegenlegacy.cpp b/src/jit/codegenlegacy.cpp
@@ -18277,8 +18277,7 @@ regMaskTP CodeGen::genCodeForCall(GenTreeCall* call, bool valUsed)
 #endif
 
 #ifdef _TARGET_ARM_
-    if (compiler->opts.ShouldUsePInvokeHelpers() && (call->gtFlags & GTF_CALL_UNMANAGED) &&
-        ((call->gtFlags & GTF_CALL_VIRT_KIND_MASK) == GTF_CALL_NONVIRT))
+    if (compiler->opts.ShouldUsePInvokeHelpers() && (call->gtFlags & GTF_CALL_UNMANAGED) && !call->IsVirtual())
     {
         (void)genPInvokeCallProlog(nullptr, 0, (CORINFO_METHOD_HANDLE) nullptr, nullptr);
     }
diff --git a/src/jit/compiler.cpp b/src/jit/compiler.cpp
@@ -7371,7 +7371,7 @@ void Compiler::compCallArgStats()
                     regArgDeferred++;
                     argTotalObjPtr++;
 
-                    if (call->gtFlags & (GTF_CALL_VIRT_VTABLE | GTF_CALL_VIRT_STUB))
+                    if (call->IsVirtual())
                     {
                         /* virtual function */
                         argVirtualCalls++;
@@ -9732,15 +9732,15 @@ int cTreeFlagsIR(Compiler* comp, GenTree* tree)
                 {
                     chars += printf("[CALL_INLINE_CANDIDATE]");
                 }
-                if (tree->gtFlags & GTF_CALL_NONVIRT)
+                if (!tree->AsCall()->IsVirtual())
                 {
                     chars += printf("[CALL_NONVIRT]");
                 }
-                if (tree->gtFlags & GTF_CALL_VIRT_VTABLE)
+                if (tree->AsCall()->IsVirtualVtable())
                 {
                     chars += printf("[CALL_VIRT_VTABLE]");
                 }
-                if (tree->gtFlags & GTF_CALL_VIRT_STUB)
+                if (tree->AsCall()->IsVirtualStub())
                 {
                     chars += printf("[CALL_VIRT_STUB]");
                 }
diff --git a/src/jit/gentree.cpp b/src/jit/gentree.cpp
@@ -4712,7 +4712,7 @@ unsigned Compiler::gtSetEvalOrder(GenTree* tree)
             else
             {
 #ifdef _TARGET_ARM_
-                if ((tree->gtFlags & GTF_CALL_VIRT_KIND_MASK) == GTF_CALL_VIRT_STUB)
+                if (tree->gtCall.IsVirtualStub())
                 {
                     // We generate movw/movt/ldr
                     costEx += (1 + IND_COST_EX);
@@ -4737,20 +4737,17 @@ unsigned Compiler::gtSetEvalOrder(GenTree* tree)
 
             level += 1;
 
-            unsigned callKind;
-            callKind = (tree->gtFlags & GTF_CALL_VIRT_KIND_MASK);
-
             /* Virtual calls are a bit more expensive */
-            if (callKind != GTF_CALL_NONVIRT)
+            if (tree->gtCall.IsVirtual())
             {
                 costEx += 2 * IND_COST_EX;
                 costSz += 2;
-            }
 
-            /* Virtual stub calls also must reserve the VIRTUAL_STUB_PARAM reg */
-            if (callKind == GTF_CALL_VIRT_STUB)
-            {
-                ftreg |= virtualStubParamInfo->GetRegMask();
+                /* Virtual stub calls also must reserve the VIRTUAL_STUB_PARAM reg */
+                if (tree->gtCall.IsVirtualStub())
+                {
+                    ftreg |= virtualStubParamInfo->GetRegMask();
+                }
             }
 
 #ifdef FEATURE_READYTORUN_COMPILER
@@ -8023,7 +8020,7 @@ GenTreePtr Compiler::gtCloneExpr(
                                               ? gtCloneExpr(tree->gtCall.gtCallAddr, addFlags, deepVarNum, deepVarVal)
                                               : nullptr;
             }
-            else if (tree->gtFlags & GTF_CALL_VIRT_STUB)
+            else if (tree->gtCall.IsVirtualStub())
             {
                 copy->gtCall.gtCallMethHnd      = tree->gtCall.gtCallMethHnd;
                 copy->gtCall.gtStubCallStubAddr = tree->gtCall.gtStubCallStubAddr;
@@ -9700,7 +9697,7 @@ void Compiler::gtDispNodeName(GenTree* tree)
 
         if (tree->gtCall.gtCallType == CT_USER_FUNC)
         {
-            if ((tree->gtFlags & GTF_CALL_VIRT_KIND_MASK) != GTF_CALL_NONVIRT)
+            if (tree->gtCall.IsVirtual())
             {
                 callType = "CALLV";
             }
@@ -9722,11 +9719,11 @@ void Compiler::gtDispNodeName(GenTree* tree)
         {
             gtfType = " nullcheck";
         }
-        if (tree->gtFlags & GTF_CALL_VIRT_VTABLE)
+        if (tree->gtCall.IsVirtualVtable())
         {
             gtfType = " ind";
         }
-        else if (tree->gtFlags & GTF_CALL_VIRT_STUB)
+        else if (tree->gtCall.IsVirtualStub())
         {
             gtfType = " stub";
         }
diff --git a/src/jit/importer.cpp b/src/jit/importer.cpp
@@ -7888,7 +7888,7 @@ var_types Compiler::impImportCall(OPCODE                  opcode,
         call->gtCall.gtCallObjp = obj;
 
         // Is this a virtual or interface call?
-        if ((call->gtFlags & GTF_CALL_VIRT_KIND_MASK) != GTF_CALL_NONVIRT)
+        if (call->gtCall.IsVirtual())
         {
             // only true object pointers can be virtual
             assert(obj->gtType == TYP_REF);
@@ -8039,10 +8039,8 @@ var_types Compiler::impImportCall(OPCODE                  opcode,
         if (canTailCall)
         {
             // True virtual or indirect calls, shouldn't pass in a callee handle.
-            CORINFO_METHOD_HANDLE exactCalleeHnd = ((call->gtCall.gtCallType != CT_USER_FUNC) ||
-                                                    ((call->gtFlags & GTF_CALL_VIRT_KIND_MASK) != GTF_CALL_NONVIRT))
-                                                       ? nullptr
-                                                       : methHnd;
+            CORINFO_METHOD_HANDLE exactCalleeHnd =
+                ((call->gtCall.gtCallType != CT_USER_FUNC) || call->gtCall.IsVirtual()) ? nullptr : methHnd;
             GenTreePtr thisArg = call->gtCall.gtCallObjp;
 
             if (info.compCompHnd->canTailCall(info.compMethodHnd, methHnd, exactCalleeHnd, explicitTailCall))
@@ -8149,9 +8147,7 @@ var_types Compiler::impImportCall(OPCODE                  opcode,
             GenTreePtr callObj = call->gtCall.gtCallObjp;
             assert(callObj != nullptr);
 
-            unsigned callKind = call->gtFlags & GTF_CALL_VIRT_KIND_MASK;
-
-            if (((callKind != GTF_CALL_NONVIRT) || (call->gtFlags & GTF_CALL_NULLCHECK)) &&
+            if ((call->gtCall.IsVirtual() || (call->gtFlags & GTF_CALL_NULLCHECK)) &&
                 impInlineIsGuaranteedThisDerefBeforeAnySideEffects(call->gtCall.gtCallArgs, callObj,
                                                                    impInlineInfo->inlArgInfo))
             {
@@ -18901,7 +18897,7 @@ void Compiler::impMarkInlineCandidate(GenTreePtr             callNode,
         return;
     }
 
-    if ((call->gtFlags & GTF_CALL_VIRT_KIND_MASK) != GTF_CALL_NONVIRT)
+    if (call->IsVirtual())
     {
         inlineResult.NoteFatal(InlineObservation::CALLSITE_IS_NOT_DIRECT);
         return;
diff --git a/src/jit/lower.cpp b/src/jit/lower.cpp
@@ -4087,7 +4087,7 @@ GenTree* Lowering::LowerVirtualVtableCall(GenTreeCall* call)
 // Lower stub dispatched virtual calls.
 GenTree* Lowering::LowerVirtualStubCall(GenTreeCall* call)
 {
-    assert((call->gtFlags & GTF_CALL_VIRT_KIND_MASK) == GTF_CALL_VIRT_STUB);
+    assert(call->IsVirtualStub());
 
     // An x86 JIT which uses full stub dispatch must generate only
     // the following stub dispatch calls:

Original file line number	Diff line number	Diff line change
`@@ -2093,7 +2093,7 @@ void Compiler::optAssertionGen(GenTreePtr tree)`
`2093`	`2093`	`case GT_CALL:`
`2094`	`2094`	`// A virtual call can create a non-null assertion. We transform some virtual calls into non-virtual calls`
`2095`	`2095`	`// with a GTF_CALL_NULLCHECK flag set.`
`2096`		`- if ((tree->gtFlags & GTF_CALL_NULLCHECK) \|\| ((tree->gtFlags & GTF_CALL_VIRT_KIND_MASK) != GTF_CALL_NONVIRT))`
	`2096`	`+ if ((tree->gtFlags & GTF_CALL_NULLCHECK) \|\| tree->AsCall()->IsVirtual())`
`2097`	`2097`	`{`
`2098`	`2098`	`// Retrieve the 'this' arg`
`2099`	`2099`	`GenTreePtr thisArg = gtGetThisArg(tree->AsCall());`
Original file line number	Diff line number	Diff line change
`@@ -18277,8 +18277,7 @@ regMaskTP CodeGen::genCodeForCall(GenTreeCall* call, bool valUsed)`
`18277`	`18277`	`#endif`
`18278`	`18278`
`18279`	`18279`	`#ifdef _TARGET_ARM_`
`18280`		`- if (compiler->opts.ShouldUsePInvokeHelpers() && (call->gtFlags & GTF_CALL_UNMANAGED) &&`
`18281`		`- ((call->gtFlags & GTF_CALL_VIRT_KIND_MASK) == GTF_CALL_NONVIRT))`
	`18280`	`+ if (compiler->opts.ShouldUsePInvokeHelpers() && (call->gtFlags & GTF_CALL_UNMANAGED) && !call->IsVirtual())`
`18282`	`18281`	`{`
`18283`	`18282`	`(void)genPInvokeCallProlog(nullptr, 0, (CORINFO_METHOD_HANDLE) nullptr, nullptr);`
`18284`	`18283`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7371,7 +7371,7 @@ void Compiler::compCallArgStats()`
`7371`	`7371`	`regArgDeferred++;`
`7372`	`7372`	`argTotalObjPtr++;`
`7373`	`7373`
`7374`		`- if (call->gtFlags & (GTF_CALL_VIRT_VTABLE \| GTF_CALL_VIRT_STUB))`
	`7374`	`+ if (call->IsVirtual())`
`7375`	`7375`	`{`
`7376`	`7376`	`/* virtual function */`
`7377`	`7377`	`argVirtualCalls++;`
`@@ -9732,15 +9732,15 @@ int cTreeFlagsIR(Compiler* comp, GenTree* tree)`
`9732`	`9732`	`{`
`9733`	`9733`	`chars += printf("[CALL_INLINE_CANDIDATE]");`
`9734`	`9734`	`}`
`9735`		`- if (tree->gtFlags & GTF_CALL_NONVIRT)`
	`9735`	`+ if (!tree->AsCall()->IsVirtual())`
`9736`	`9736`	`{`
`9737`	`9737`	`chars += printf("[CALL_NONVIRT]");`
`9738`	`9738`	`}`
`9739`		`- if (tree->gtFlags & GTF_CALL_VIRT_VTABLE)`
	`9739`	`+ if (tree->AsCall()->IsVirtualVtable())`
`9740`	`9740`	`{`
`9741`	`9741`	`chars += printf("[CALL_VIRT_VTABLE]");`
`9742`	`9742`	`}`
`9743`		`- if (tree->gtFlags & GTF_CALL_VIRT_STUB)`
	`9743`	`+ if (tree->AsCall()->IsVirtualStub())`
`9744`	`9744`	`{`
`9745`	`9745`	`chars += printf("[CALL_VIRT_STUB]");`
`9746`	`9746`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4712,7 +4712,7 @@ unsigned Compiler::gtSetEvalOrder(GenTree* tree)`
`4712`	`4712`	`else`
`4713`	`4713`	`{`
`4714`	`4714`	`#ifdef _TARGET_ARM_`
`4715`		`- if ((tree->gtFlags & GTF_CALL_VIRT_KIND_MASK) == GTF_CALL_VIRT_STUB)`
	`4715`	`+ if (tree->gtCall.IsVirtualStub())`
`4716`	`4716`	`{`
`4717`	`4717`	`// We generate movw/movt/ldr`
`4718`	`4718`	`costEx += (1 + IND_COST_EX);`
`@@ -4737,20 +4737,17 @@ unsigned Compiler::gtSetEvalOrder(GenTree* tree)`
`4737`	`4737`
`4738`	`4738`	`level += 1;`
`4739`	`4739`
`4740`		`- unsigned callKind;`
`4741`		`- callKind = (tree->gtFlags & GTF_CALL_VIRT_KIND_MASK);`
`4742`		`-`
`4743`	`4740`	`/* Virtual calls are a bit more expensive */`
`4744`		`- if (callKind != GTF_CALL_NONVIRT)`
	`4741`	`+ if (tree->gtCall.IsVirtual())`
`4745`	`4742`	`{`
`4746`	`4743`	`costEx += 2 * IND_COST_EX;`
`4747`	`4744`	`costSz += 2;`
`4748`		`- }`
`4749`	`4745`
`4750`		`- /* Virtual stub calls also must reserve the VIRTUAL_STUB_PARAM reg */`
`4751`		`- if (callKind == GTF_CALL_VIRT_STUB)`
`4752`		`- {`
`4753`		`- ftreg \|= virtualStubParamInfo->GetRegMask();`
	`4746`	`+ /* Virtual stub calls also must reserve the VIRTUAL_STUB_PARAM reg */`
	`4747`	`+ if (tree->gtCall.IsVirtualStub())`
	`4748`	`+ {`
	`4749`	`+ ftreg \|= virtualStubParamInfo->GetRegMask();`
	`4750`	`+ }`
`4754`	`4751`	`}`
`4755`	`4752`
`4756`	`4753`	`#ifdef FEATURE_READYTORUN_COMPILER`
`@@ -8023,7 +8020,7 @@ GenTreePtr Compiler::gtCloneExpr(`
`8023`	`8020`	`? gtCloneExpr(tree->gtCall.gtCallAddr, addFlags, deepVarNum, deepVarVal)`
`8024`	`8021`	`: nullptr;`
`8025`	`8022`	`}`
`8026`		`- else if (tree->gtFlags & GTF_CALL_VIRT_STUB)`
	`8023`	`+ else if (tree->gtCall.IsVirtualStub())`
`8027`	`8024`	`{`
`8028`	`8025`	`copy->gtCall.gtCallMethHnd = tree->gtCall.gtCallMethHnd;`
`8029`	`8026`	`copy->gtCall.gtStubCallStubAddr = tree->gtCall.gtStubCallStubAddr;`
`@@ -9700,7 +9697,7 @@ void Compiler::gtDispNodeName(GenTree* tree)`
`9700`	`9697`
`9701`	`9698`	`if (tree->gtCall.gtCallType == CT_USER_FUNC)`
`9702`	`9699`	`{`
`9703`		`- if ((tree->gtFlags & GTF_CALL_VIRT_KIND_MASK) != GTF_CALL_NONVIRT)`
	`9700`	`+ if (tree->gtCall.IsVirtual())`
`9704`	`9701`	`{`
`9705`	`9702`	`callType = "CALLV";`
`9706`	`9703`	`}`
`@@ -9722,11 +9719,11 @@ void Compiler::gtDispNodeName(GenTree* tree)`
`9722`	`9719`	`{`
`9723`	`9720`	`gtfType = " nullcheck";`
`9724`	`9721`	`}`
`9725`		`- if (tree->gtFlags & GTF_CALL_VIRT_VTABLE)`
	`9722`	`+ if (tree->gtCall.IsVirtualVtable())`
`9726`	`9723`	`{`
`9727`	`9724`	`gtfType = " ind";`
`9728`	`9725`	`}`
`9729`		`- else if (tree->gtFlags & GTF_CALL_VIRT_STUB)`
	`9726`	`+ else if (tree->gtCall.IsVirtualStub())`
`9730`	`9727`	`{`
`9731`	`9728`	`gtfType = " stub";`
`9732`	`9729`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4087,7 +4087,7 @@ GenTree* Lowering::LowerVirtualVtableCall(GenTreeCall* call)`
`4087`	`4087`	`// Lower stub dispatched virtual calls.`
`4088`	`4088`	`GenTree* Lowering::LowerVirtualStubCall(GenTreeCall* call)`
`4089`	`4089`	`{`
`4090`		`- assert((call->gtFlags & GTF_CALL_VIRT_KIND_MASK) == GTF_CALL_VIRT_STUB);`
	`4090`	`+ assert(call->IsVirtualStub());`
`4091`	`4091`
`4092`	`4092`	`// An x86 JIT which uses full stub dispatch must generate only`
`4093`	`4093`	`// the following stub dispatch calls:`