Remove FCall to Call convertion and re-convertion

Remain G4_pseudo_fcall operand and lower it to Gen call instruction at
encoder to avoid conversion and recovertion between FCall and Call.

Author: DianaChen

visa/BinaryEncoding.cpp

@@ -1557,8 +1557,9 @@ BinaryEncoding::Status BinaryEncoding::EncodeOperandDst(G4_INST* inst)
 inline BinaryEncoding::Status BinaryEncoding::EncodeOperandSrc0(G4_INST* inst)
 {
     Status myStatus = SUCCESS;
-    if (inst->isLabel()  ||
-         inst->isCall())
+    if (inst->isLabel() ||
+         inst->isCall() ||
+         inst->isFCall())
         return myStatus;
 
     if (inst->isSplitSend())
@@ -3168,7 +3169,7 @@ bool BinaryEncoding::EncodeConditionalBranches(G4_INST *inst,
         }
     }
 
-    if (op == G4_call && inst->getSrc(0))
+    if ((op == G4_call || op == G4_pseudo_fcall) && inst->getSrc(0))
     {
 
         if (inst->getSrc(0)->isLabel())

visa/BinaryEncoding.h

@@ -819,13 +819,13 @@ namespace vISA
             }
 
             // ToDo: disable compacting nop/return until it is clear that we can compact them
-            if (op == G4_nop || op == G4_return)
+            if (op == G4_nop || op == G4_return || op == G4_pseudo_fret)
             {
                 return false;
             }
 
             // temporary WA, to be removed later
-            if (op == G4_call)
+            if (op == G4_call || op == G4_pseudo_fcall)
             {
                 return false;
             }

visa/BinaryEncodingCNL.cpp

@@ -105,6 +105,7 @@ uint32_t BinaryEncodingBase::getEUOpcode(G4_opcode g4opc)
     case G4_brd: euopcode = G9HDL::EU_OPCODE_BRD; break;
     case G4_break: euopcode = G9HDL::EU_OPCODE_BREAK; break;
     case G4_call: euopcode = G9HDL::EU_OPCODE_CALL; break;
+    case G4_pseudo_fcall: euopcode = G9HDL::EU_OPCODE_CALL; break;
         //case G4_calla: euopcode = G9HDL::EU_OPCODE_CALLA; break;
     case G4_cont: euopcode = G9HDL::EU_OPCODE_CONT; break;
     case G4_else: euopcode = G9HDL::EU_OPCODE_ELSE; break;
@@ -114,7 +115,10 @@ uint32_t BinaryEncodingBase::getEUOpcode(G4_opcode g4opc)
     case G4_if: euopcode = G9HDL::EU_OPCODE_IF; break;
     case G4_jmpi: euopcode = G9HDL::EU_OPCODE_JMPI; break;
     case G4_join: euopcode = G9HDL::EU_OPCODE_JOIN; break;
-    case G4_return: euopcode = G9HDL::EU_OPCODE_RET; break;
+    case G4_return:
+    case G4_pseudo_fret:
+        euopcode = G9HDL::EU_OPCODE_RET;
+        break;
     case G4_wait: euopcode = G9HDL::EU_OPCODE_WAIT; break;
     case G4_while: euopcode = G9HDL::EU_OPCODE_WHILE; break;
 
@@ -1744,8 +1748,8 @@ bool BinaryEncodingCNL::EncodeConditionalBranches(G4_INST *inst,
         }
     }
 
-    if (op == G4_call              &&
-         inst->getSrc(0)            &&
+    if ((op == G4_call || op == G4_pseudo_fcall) &&
+         inst->getSrc(0) &&
          inst->getSrc(0)->isLabel())
     {
         G4_Operand *opnd = inst->getSrc(0);
@@ -2389,7 +2393,7 @@ BinaryEncodingCNL::Status BinaryEncodingCNL::DoAllEncoding(G4_INST* inst)
         {
             DoAllEncodingCF(inst);
         }
-        else if (inst->opcode() == G4_call)
+        else if (inst->opcode() == G4_call || inst->opcode() == G4_pseudo_fcall)
         {
             DoAllEncodingCALL(inst);
         }

visa/BinaryEncodingIGA.cpp

@@ -263,8 +263,15 @@ std::pair<iga::Op,iga::Subfunction> BinaryEncodingIGA::getIgaOpInfo(
     case G4_break:   igaOp = iga::Op::BREAK; break;
     case G4_cont:    igaOp = iga::Op::CONT; break;
     case G4_halt:    igaOp = iga::Op::HALT; break;
-    case G4_call:    igaOp = iga::Op::CALL; break;
-    case G4_return:  igaOp = iga::Op::RET; break;
+    case G4_call:
+    case G4_pseudo_fcall:
+        //TODO: select calla for indirect call
+        igaOp = iga::Op::CALL;
+        break;
+    case G4_return:
+    case G4_pseudo_fret:
+        igaOp = iga::Op::RET;
+        break;
     case G4_goto:    igaOp = iga::Op::GOTO; break;
     case G4_join:    igaOp = iga::Op::JOIN; break;
     case G4_wait:
@@ -352,8 +359,6 @@ std::pair<iga::Op,iga::Subfunction> BinaryEncodingIGA::getIgaOpInfo(
     case G4_pseudo_or:    igaOp = iga::Op::OR; break;
     case G4_pseudo_xor:   igaOp = iga::Op::XOR; break;
     case G4_pseudo_not:   igaOp = iga::Op::NOT; break;
-    case G4_pseudo_fcall: igaOp = iga::Op::CALL; break;
-    case G4_pseudo_fret:  igaOp = iga::Op::RET; break;
     case G4_pseudo_sada2: igaOp = iga::Op::SADA2; break;
     case G4_pseudo_exit:
         ASSERT_USER(!allowUnknownOp, "G4_pseudo_exit not GEN ISA OPCODE.");

visa/BuildCISAIRImpl.cpp

@@ -404,20 +404,13 @@ int CISA_IR_Builder::AddFunction(VISAFunction *& function, const char* functionN
 void restoreFCallState(
     G4_Kernel* kernel, const std::map<G4_BB*, G4_INST*>& savedFCallState)
 {
-    // Iterate over all BBs in kernel and fix all fcalls converted
-    // to calls by reconverting them to fcall. This is required
-    // because we want to reuse IR of function for next kernel.
-
+    // Iterate over all BBs in kernel and clean up the edges.
+    // FIXME: do we need to do this still?
     for (auto&& iter : savedFCallState)
     {
         auto curBB = iter.first;
-        auto genOffset = curBB->back()->getGenOffset();
-        curBB->pop_back();
         auto origInst = iter.second;
         assert(origInst->isFCall() || origInst->isFReturn());
-        curBB->push_back(origInst);
-        // set the genOffset in case of GenOffset being used when creating symbol table
-        origInst->setGenOffset(genOffset);
 
         if (origInst->isFCall() && !origInst->asCFInst()->isIndirectCall())
         {
@@ -447,7 +440,6 @@ void restoreFCallState(
 
 // Stitch the FG of subFunctions to mainFunc
 // mainFunc could be a kernel or a non-kernel function.
-// It also modifies pseudo_fcall/fret in to call/ret opcodes.
 // ToDo: may consider stitching only functions that may be called by this kernel/function
 static void Stitch_Compiled_Units(
     G4_Kernel* mainFunc, std::map<std::string, G4_Kernel*>& subFuncs,
@@ -471,8 +463,7 @@ static void Stitch_Compiled_Units(
     mainFunc->fg.reassignBlockIDs();
     mainFunc->fg.setPhysicalPredSucc(); // this is to locate the next BB after an fcall
 
-    auto builder = mainFunc->fg.builder;
-    // Change fcall/fret to call/ret and setup caller/callee edges
+    // setup caller/callee edges
     for (G4_BB* cur : mainFunc->fg)
     {
         if (cur->isEndWithFCall())
@@ -500,47 +491,11 @@ static void Stitch_Compiled_Units(
                 // Connect new fg
                 mainFunc->fg.addPredSuccEdges(cur, callee->fg.getEntryBB());
                 mainFunc->fg.addPredSuccEdges(callee->fg.getUniqueReturnBlock(), retBlock);
-
-                G4_INST* calleeLabel = callee->fg.getEntryBB()->front();
-                ASSERT_USER(calleeLabel->isLabel() == true, "Entry inst is not label");
-
-                auto callInst = builder->createInternalInst(
-                    fcall->getPredicate(), G4_call, nullptr, g4::NOSAT, fcall->getExecSize(),
-                    fcall->getDst(), calleeLabel->getSrc(0), fcall->getSrc(0), fcall->getOption());
-                callInst->inheritDIFrom(fcall);
-                cur->pop_back();
-                cur->push_back(callInst);
-            }
-            else
-            {
-                // src0 is dont care for indirect call as long it's not a label
-                auto callInst = builder->createInternalInst(
-                    fcall->getPredicate(), G4_call, nullptr, g4::NOSAT, fcall->getExecSize(),
-                    fcall->getDst(), fcall->getSrc(0), fcall->getSrc(0), fcall->getOption());
-                callInst->inheritDIFrom(fcall);
-                cur->pop_back();
-                cur->push_back(callInst);
             }
             FCallRetMap[cur] = fcall;
         }
     }
 
-    // Change fret to ret
-    for (G4_BB* cur : mainFunc->fg)
-    {
-        if (cur->isEndWithFRet())
-        {
-            G4_INST* fret = cur->back();
-            auto retInst = builder->createInternalInst(
-                fret->getPredicate(), G4_return, nullptr, g4::NOSAT, fret->getExecSize(),
-                builder->createNullDst(Type_UD), fret->getSrc(0), fret->getSrc(1), fret->getOption());
-            retInst->inheritDIFrom(fret);
-            cur->pop_back();
-            cur->push_back(retInst);
-            FCallRetMap[cur] = fret;
-        }
-    }
-
     // Append declarations and color attributes from all callees to mainFunc
     for (auto iter : subFuncs)
     {

visa/Common_BinaryEncoding.h

@@ -1596,7 +1596,7 @@ namespace vISA
             op == G4_halt ||
             op == G4_endif)
             return true;
-        else if (op == G4_call             &&
+        else if ((op == G4_call || op == G4_pseudo_fcall) &&
             inst->getSrc(0) &&
             inst->getSrc(0)->isLabel())
         {
@@ -2289,7 +2289,7 @@ namespace vISA
         // temporary WA, to be removed later
         // we disable compacting nop/return
         // until it is clear that we can compact them
-        if (op == G4_call || op == G4_return)
+        if (op == G4_call || op == G4_pseudo_fcall || op == G4_return || op == G4_pseudo_fret)
         {
             return false;
         }

visa/LocalScheduler/SWSB_G4IR.cpp

@@ -531,7 +531,7 @@ void SWSB::SWSBBuildSIMDCFG()
                     }
                 }
             }
-            else if (lastInst->isReturn() || lastInst->isCall())
+            else if (lastInst->isReturn() || lastInst->isCall() || lastInst->isFCall() || lastInst->isFReturn())
             {
                 BB_LIST_ITER iter = currBB->getBB()->Succs.begin();
                 while (iter != currBB->getBB()->Succs.end())
@@ -671,7 +671,8 @@ void SWSB::handleIndirectCall()
         SBNode* node = SBNodes[BBVector[i]->last_node];
 
         if ((node->GetInstruction()->isCall() && !node->GetInstruction()->getSrc(0)->isLabel()) ||
-            node->GetInstruction()->isReturn())
+            node->GetInstruction()->isReturn() ||
+            node->GetInstruction()->isFReturn())
         {
             LiveGRFBuckets send_use_out(mem, kernel.getNumRegTotal(), *fg.getKernel());
             for (size_t j = 0; j < globalSendOpndList.size(); j++)
@@ -692,7 +693,7 @@ void SWSB::handleIndirectCall()
                 }
             }
         }
-        if (node->GetInstruction()->isReturn())
+        if (node->GetInstruction()->isReturn() || node->GetInstruction()->isFReturn())
         {
             node->GetInstruction()->setDistance(1);
         }
@@ -999,6 +1000,7 @@ static bool isBranch(SBNode* N) {
         return false;
     // Skip function call/ret.
     if (Inst->isCall() || Inst->isReturn() ||
+        Inst->isFCall() || Inst->isFReturn() ||
         Inst->opcode() == G4_pseudo_fc_call ||
         Inst->opcode() == G4_pseudo_fc_ret)
         return false;

visa/Optimizer.cpp

@@ -7578,7 +7578,7 @@ bool Optimizer::foldPseudoAndOr(G4_BB* bb, INST_LIST_ITER& ii)
         // check every fcall
         for (auto bb : kernel.fg)
         {
-            if (bb->back()->isFCall())
+            if (bb->isEndWithFCall())
             {
                 G4_INST* fcall = bb->back();
                 if (fcall->getSrc(0)->isGreg() || fcall->getSrc(0)->isA0()) {

visa/VISAKernelImpl.cpp

@@ -273,7 +273,7 @@ void VISAKernelImpl::adjustIndirectCallOffset()
             continue;
 
         // At this point G4_pseudo_fcall may be converted to G4_call
-        if (bb->back()->isCall() || bb->back()->isFCall())
+        if (bb->isEndWithCall() || bb->isEndWithFCall())
         {
             G4_INST* fcall = bb->back();
             if (fcall->getSrc(0)->isGreg() || fcall->getSrc(0)->isA0())