Line data    Source code

       1              : /*
       2              :  * Copyright (c) Huawei Technologies Co., Ltd. 2024-2024. All rights reserved.
       3              :  * Description: ccu representation implementation file
       4              :  * Author: sunzhepeng
       5              :  * Create: 2024-06-17
       6              :  */
       7              : 
       8              : #include "ccu_rep_v1.h"
       9              : #include "ccu_ins_generater_v1.h"
      10              : #include "string_util.h"
      11              : #include "exception_util.h"
      12              : #include "ccu_api_exception.h"
      13              : #include "ccu_kernel.h"
      14              : 
      15              : namespace hcomm {
      16              : namespace CcuRep {
      17              : 
      18          203 : void CcuRepAssign::SetCommonInfo()
      19              : {
      20          203 :     type       = CcuRepType::ASSIGN;
      21          203 :     instrCount = 1;
      22          203 : }
      23              : 
      24          103 : CcuRepAssign::CcuRepAssign(CcuInsGeneraterBase* insGenPtr, const Variable &varA, uint64_t immediate)
      25          103 :     : insGenPtr(insGenPtr), subType(AssignSubType::IMD_TO_VARIABLE), immediate(immediate), varA(varA)
      26              : {
      27          103 :     SetCommonInfo();
      28          103 : }
      29              : 
      30           10 : CcuRepAssign::CcuRepAssign(CcuInsGeneraterBase* insGenPtr, const Address &addrA, uint64_t immediate)
      31           10 :     : insGenPtr(insGenPtr), subType(AssignSubType::IMD_TO_ADDR), immediate(immediate), addrA(addrA)
      32              : {
      33           10 :     SetCommonInfo();
      34           10 : }
      35              : 
      36           13 : CcuRepAssign::CcuRepAssign(CcuInsGeneraterBase* insGenPtr, const Address &addrA, const Variable &varA)
      37           13 :     : insGenPtr(insGenPtr), subType(AssignSubType::VAR_TO_ADDR), immediate(0), varA(varA), addrA(addrA)
      38              : {
      39           13 :     SetCommonInfo();
      40           13 : }
      41              : 
      42           26 : CcuRepAssign::CcuRepAssign(CcuInsGeneraterBase* insGenPtr, const Address &addrB, const Address &addrA)
      43           26 :     : insGenPtr(insGenPtr), subType(AssignSubType::ADDR_TO_ADDR), immediate(0), addrA(addrA), addrB(addrB)
      44              : {
      45           26 :     SetCommonInfo();
      46           26 : }
      47              : 
      48           51 : CcuRepAssign::CcuRepAssign(CcuInsGeneraterBase* insGenPtr, const Variable &varB, const Variable &varA)
      49           51 :     : insGenPtr(insGenPtr), subType(AssignSubType::VAR_TO_VAR), immediate(0), varA(varA), varB(varB)
      50              : {
      51           51 :     SetCommonInfo();
      52           51 : }
      53              : 
      54          184 : bool CcuRepAssign::Translate(CcuKernel* ccuKernel, CcuInstr *&instr, uint16_t &instrId, const TransDep &dep)
      55              : {
      56          184 :     Hccl::CHECK_NULLPTR(instr, "[CcuRepAssign::Translate] instr is nullptr!");
      57          184 :     this->instrId = instrId;
      58          184 :     translated    = true;
      59              : 
      60          184 :     insGenPtr->CcuRepAssignTranslate(ccuKernel, instr, this, dep);
      61              :     
      62          184 :     CHK_PRT_THROW((instrId > UINT16_MAX - instrCount),
      63              :                         HCCL_ERROR("[CcuRepAssign::Translate]uint16 integer overflow occurs, instrId = [%hu], instrCount = [%hu]", instrId, instrCount),
      64              :                           Hccl::InternalException, "integer overflow");
      65          184 :     instrId += instrCount;
      66              : 
      67          184 :     return translated;
      68              : }
      69              : 
      70          184 : std::string CcuRepAssign::Describe()
      71              : {
      72          184 :     switch (subType) {
      73           96 :         case AssignSubType::IMD_TO_VARIABLE: {
      74           96 :             return Hccl::StringFormat("Variable[%u] = Value[%lu]", varA.Id(), immediate);
      75              :         }
      76            7 :         case AssignSubType::IMD_TO_ADDR: {
      77            7 :             return Hccl::StringFormat("Address[%u] = Value[%lu]", addrA.Id(), immediate);
      78              :         }
      79           10 :         case AssignSubType::VAR_TO_ADDR: {
      80           10 :             return Hccl::StringFormat("Address[%u] = Variable[%u]", addrA.Id(), varA.Id());
      81              :         }
      82           23 :         case AssignSubType::ADDR_TO_ADDR: {
      83           23 :             return Hccl::StringFormat("Address[%u] = Address[%u]", addrB.Id(), addrA.Id());
      84              :         }
      85           48 :         case AssignSubType::VAR_TO_VAR: {
      86           48 :             return Hccl::StringFormat("Var[%u] = Var[%u]", varB.Id(), varA.Id());
      87              :         }
      88            0 :         default: {
      89            0 :             return Hccl::StringFormat("Invalid Assign");
      90              :         }
      91              :     }
      92              : }
      93              : 
      94           40 : Address CcuRepAssign::GetAddrA()
      95              : {
      96           40 :     return addrA;
      97              : }
      98              : 
      99           23 : Address CcuRepAssign::GetAddrB()
     100              : {
     101           23 :     return addrB;
     102              : }
     103              : 
     104          200 : Variable CcuRepAssign::GetVarA()
     105              : {
     106          200 :     return varA;
     107              : }
     108              : 
     109           94 : Variable CcuRepAssign::GetVarB()
     110              : {
     111           94 :     return varB;
     112              : }
     113              : 
     114          105 : uint64_t CcuRepAssign::GetImmed()
     115              : {
     116          105 :     return immediate;
     117              : }
     118              : 
     119          377 : AssignSubType CcuRepAssign::GetSubType()
     120              : {
     121          377 :     return subType;
     122              : }
     123              : }; // namespace CcuRep
     124              : }; // namespace hcomm