vISA: Re-adjust indirect call target offset after swsb

Change-Id: If74854a8bd161354264cdfc669af7a048701d2b9

Author: DianaChen

visa/Optimizer.cpp

@@ -6894,6 +6894,14 @@ bool Optimizer::foldPseudoAndOr(G4_BB* bb, INST_LIST_ITER& ii)
             // also return the call with jmpi in VISAKernelImpl::compilePostOptimize
             replaceRetWithJmpi();
         }
+
+        if (kernel.hasIndirectCall())
+        {
+            // If the indirect call has regiser src0, the register must be a
+            // ip-based address of the call target. Insert a add before call to
+            // calculate the relative offset from call to the target
+            expandIndirectCallWithRegTarget();
+        }
     }
 
 class NSDS {
@@ -8259,6 +8267,152 @@ void genBucket(G4_INST *send, Bucket *bucket, RW rwType) {
         }
     }
 
+    G4_Declare* Optimizer::createInstsForCallTargetOffset(
+        InstListType& insts, G4_INST* fcall, int64_t adjust_off)
+    {
+        // create instruction sequence:
+        //       add  r2.0  -IP   call_target
+        //       add  r2.0  r2.0  adjust_off
+
+        // call's dst must be r1.0, which is reserved at
+        // GlobalRA::setABIForStackCallFunctionCalls. It must not be overlapped with
+        // r2.0, that is hardcoded as the new jump target
+        assert(fcall->getDst()->isGreg());
+        assert((fcall->getDst()->getLinearizedStart() / GENX_GRF_REG_SIZ) != 2);
+
+        // hardcoded add's dst to r2.0
+        G4_Declare* add_dst_decl =
+            builder.createHardwiredDeclare(1, fcall->getDst()->getType(), 2, 0);
+
+        // create the first add instruction
+        // add  r2.0  -IP   call_target
+        G4_INST* add_inst = builder.createBinOp(
+            G4_add, 1,
+            builder.Create_Dst_Opnd_From_Dcl(add_dst_decl, 1),
+            builder.createSrcRegRegion(
+                Mod_Minus, Direct, builder.phyregpool.getIpReg(), 0, 0,
+                builder.getRegionScalar(), Type_UD),
+            fcall->getSrc(0), InstOpt_WriteEnable | InstOpt_NoCompact, false);
+
+        // create the second add to add the -ip to adjust_off, adjust_off dependes
+        // on how many instructions from the fist add to the jmp instruction, and
+        // if it's post-increment (jmpi) or pre-increment (call)
+        // add  r2.0  r2.0  adjust_off
+        G4_INST* add_inst2 = builder.createBinOp(
+            G4_add, 1,
+            builder.Create_Dst_Opnd_From_Dcl(add_dst_decl, 1),
+            builder.Create_Src_Opnd_From_Dcl(
+                add_dst_decl, builder.getRegionScalar()),
+            builder.createImm(adjust_off, Type_D),
+            InstOpt_WriteEnable | InstOpt_NoCompact, false);
+
+        insts.push_back(add_inst);
+        insts.push_back(add_inst2);
+
+        return add_dst_decl;
+    }
+
+    void Optimizer::createInstForJmpiSequence(InstListType& insts, G4_INST* fcall)
+    {
+        // SKL workaround for indirect call
+        // r1.0 is the return IP (the instruction right after jmpi)
+        // r1.1 is the return mask. While we'll replace the ret in calee to jmpi as well,
+        // we do not need to consider the return mask here.
+
+        // Do not allow predicate call on jmpi WA
+        assert(fcall->getPredicate() == nullptr);
+
+        // calculate the reserved register's num from fcall's dst register (shoud be r1)
+        assert(fcall->getDst()->isGreg());
+        uint32_t reg_num = fcall->getDst()->getLinearizedStart() / GENX_GRF_REG_SIZ;
+
+        G4_Declare* new_target_decl = createInstsForCallTargetOffset(insts, fcall, -64);
+
+        // add  r1.0   IP   32
+        G4_Declare* r1_0_decl =
+            builder.createHardwiredDeclare(1, fcall->getDst()->getType(), reg_num, 0);
+        insts.push_back(builder.createBinOp(
+            G4_add, 1,
+            builder.Create_Dst_Opnd_From_Dcl(r1_0_decl, 1),
+            builder.createSrcRegRegion(
+                Mod_src_undef, Direct, builder.phyregpool.getIpReg(), 0, 0,
+                builder.getRegionScalar(), Type_UD),
+            builder.createImm(32, Type_UD),
+            InstOpt_WriteEnable | InstOpt_NoCompact, false));
+
+        // jmpi r2.0
+        // update jump target (src0) to add's dst
+        G4_SrcRegRegion* jump_target = builder.Create_Src_Opnd_From_Dcl(
+            new_target_decl, builder.getRegionScalar());
+        jump_target->setType(Type_D);
+        insts.push_back(builder.createJmp(nullptr, jump_target, InstOpt_NoCompact, false));
+    }
+
+    void Optimizer::expandIndirectCallWithRegTarget()
+    {
+        // check every fcall
+        for (auto bb : kernel.fg)
+        {
+            // At this point G4_pseudo_fcall may be converted to G4_call,
+            // check all call (???)
+            if (bb->back()->isFCall()) //|| bb->back()->isCall())
+            {
+                G4_INST* fcall = bb->back();
+                if (fcall->getSrc(0)->isGreg() || fcall->getSrc(0)->isA0()) {
+                    // at this point the call instruction's src0 has the target_address
+                    // and the call dst is the reserved register for ret
+                    // All the caller save register should be saved. We usd r2.0 directly
+                    // here to calculate the new call's target. We picked r2.0 due to the
+                    // HW's limitation that call/calla's src and dst offset (the subreg num)
+                    // must be 0.
+                    //
+                    // expand call
+                    // From:
+                    //       call r1.0 call_target
+                    // To:
+                    //       add  r2.0  -IP   call_target
+                    //       add  r2.0  r2.0  -32
+                    //       call r1.0  r2.0
+
+                    // For SKL workaround, expand call
+                    // From:
+                    //       call r1.0 call_target
+                    // To:
+                    //       add  r2.0   -IP    call_target
+                    //       add  r2.0   r2.0   -64
+                    //       add  r1.0   IP   32              // set the return IP
+                    //       jmpi r2.0
+
+                    InstListType expanded_insts;
+                    if (builder.needReplaceIndirectCallWithJmpi()) {
+                        createInstForJmpiSequence(expanded_insts, fcall);
+                    }
+                    else {
+                        G4_Declare* jmp_target_decl =
+                            createInstsForCallTargetOffset(expanded_insts, fcall, -32);
+                        // Updated call's target to the new target
+                        G4_SrcRegRegion* jump_target = builder.Create_Src_Opnd_From_Dcl(
+                            jmp_target_decl, builder.getRegionScalar());
+                        fcall->setSrc(jump_target, 0);
+                        fcall->setNoCompacted();
+                    }
+                    // then insert the expaneded instructions right before the call
+                    INST_LIST_ITER insert_point = bb->end();
+                    --insert_point;
+                    for (auto inst_to_add : expanded_insts) {
+                        bb->getInstList().insert(insert_point, inst_to_add);
+                        inst_to_add->setCISAOff(fcall->getCISAOff());
+                    }
+
+                    // remove call from the instlist for Jmpi WA
+                    if (builder.needReplaceIndirectCallWithJmpi())
+                        bb->getInstList().erase(--bb->end());
+                }
+            }
+        }
+
+    }
+
     // Replace ret with jmpi, must be single return
     void Optimizer::replaceRetWithJmpi()
     {

visa/Optimizer.h

@@ -252,6 +252,15 @@ class Optimizer
     void replaceRetWithJmpi();
     void doNoMaskWA();
     void insertFenceAtEntry();
+
+    typedef std::vector<vISA::G4_INST*> InstListType;
+    void expandIndirectCallWithRegTarget();
+    void createInstForJmpiSequence(InstListType& insts, G4_INST* fcall);
+    // create the instructions to calculate the jump target offset, return G4_Declare of the
+    // new created jmp target
+    G4_Declare* createInstsForCallTargetOffset(
+        InstListType& insts, G4_INST* fcall, int64_t adjust_off);
+
     void insertHashMovs();
     void insertDummyCompactInst();
     void removeLifetimeOps();

visa/VISAKernel.h

@@ -43,8 +43,6 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //forward declaration
 namespace vISA
 {
-class G4_Declare;
-class G4_INST;
 class G4_Kernel;
 class DebugInfoFormat;
 class BinaryEncodingBase;
@@ -855,14 +853,8 @@ class VISAKernelImpl : public VISAFunction
     int calculateTotalInputSize();
     int compileTillOptimize();
 
-    // Expand indirect call
-    typedef std::vector<vISA::G4_INST*> InstListType;
-    void expandIndirectCallWithRegTarget();
-    void createInstForJmpiSequence(InstListType& insts, vISA::G4_INST* fcall);
-    // create the instructions to calculate the jump target offset, return G4_Declare of the
-    // new created jmp target
-    vISA::G4_Declare* createInstsForCallTargetOffset(
-        InstListType& insts, vISA::G4_INST* fcall, int64_t adjust_off);
+    // Re-adjust indirect call target after swsb
+    void adjustIndirectCallOffset();
 
     CisaFramework::CisaInst* AppendVISASvmGeneralScatterInst(VISA_PredOpnd* pred,
         VISA_EMask_Ctrl emask, VISA_Exec_Size execSize, unsigned char blockSize,