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_generator_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          366 : void CcuRepAssign::SetCommonInfo()
      19              : {
      20          366 :     type       = CcuRepType::ASSIGN;
      21          366 :     instrCount = insGenPtr->GetInstrCount(type);
      22          366 : }
      23              : 
      24          210 : CcuRepAssign::CcuRepAssign(CcuInsGeneratorBase* insGenPtr, const Variable &varA, uint64_t immediate)
      25          210 :     : insGenPtr(insGenPtr), subType(AssignSubType::IMD_TO_VARIABLE), immediate(immediate), varA(varA)
      26              : {
      27          210 :     SetCommonInfo();
      28          210 : }
      29              : 
      30           15 : CcuRepAssign::CcuRepAssign(CcuInsGeneratorBase* insGenPtr, const Address &addrA, uint64_t immediate)
      31           15 :     : insGenPtr(insGenPtr), subType(AssignSubType::IMD_TO_ADDR), immediate(immediate), addrA(addrA)
      32              : {
      33           15 :     SetCommonInfo();
      34           15 : }
      35              : 
      36           18 : CcuRepAssign::CcuRepAssign(CcuInsGeneratorBase* insGenPtr, const Address &addrA, const Variable &varA)
      37           18 :     : insGenPtr(insGenPtr), subType(AssignSubType::VAR_TO_ADDR), immediate(0), varA(varA), addrA(addrA)
      38              : {
      39           18 :     SetCommonInfo();
      40           18 : }
      41              : 
      42           42 : CcuRepAssign::CcuRepAssign(CcuInsGeneratorBase* insGenPtr, const Address &addrB, const Address &addrA)
      43           42 :     : insGenPtr(insGenPtr), subType(AssignSubType::ADDR_TO_ADDR), immediate(0), addrA(addrA), addrB(addrB)
      44              : {
      45           42 :     SetCommonInfo();
      46           42 : }
      47              : 
      48           81 : CcuRepAssign::CcuRepAssign(CcuInsGeneratorBase* insGenPtr, const Variable &varB, const Variable &varA)
      49           81 :     : insGenPtr(insGenPtr), subType(AssignSubType::VAR_TO_VAR), immediate(0), varA(varA), varB(varB)
      50              : {
      51           81 :     SetCommonInfo();
      52           81 : }
      53              : 
      54          325 : bool CcuRepAssign::Translate(CcuKernel* ccuKernel, CcuInstr *&instr, uint16_t &instrId, const TransDep &dep)
      55              : {
      56          325 :     Hccl::CHECK_NULLPTR(instr, "[CcuRepAssign::Translate] instr is nullptr!");
      57          325 :     this->instrId = instrId;
      58          325 :     translated    = true;
      59              : 
      60          325 :     insGenPtr->CcuRepAssignTranslate(ccuKernel, instr, this, dep);
      61              :     
      62          325 :     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          325 :     instrId += instrCount;
      66              : 
      67          325 :     return translated;
      68              : }
      69              : 
      70          323 : std::string CcuRepAssign::Describe()
      71              : {
      72          323 :     switch (subType) {
      73          183 :         case AssignSubType::IMD_TO_VARIABLE: {
      74          183 :             return Hccl::StringFormat("Variable[%u] = Value[%lu]", varA.Id(), immediate);
      75              :         }
      76            9 :         case AssignSubType::IMD_TO_ADDR: {
      77            9 :             return Hccl::StringFormat("Address[%u] = Value[%lu]", addrA.Id(), immediate);
      78              :         }
      79           15 :         case AssignSubType::VAR_TO_ADDR: {
      80           15 :             return Hccl::StringFormat("Address[%u] = Variable[%u]", addrA.Id(), varA.Id());
      81              :         }
      82           39 :         case AssignSubType::ADDR_TO_ADDR: {
      83           39 :             return Hccl::StringFormat("Address[%u] = Address[%u]", addrB.Id(), addrA.Id());
      84              :         }
      85           77 :         case AssignSubType::VAR_TO_VAR: {
      86           77 :             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           63 : Address CcuRepAssign::GetAddrA()
      95              : {
      96           63 :     return addrA;
      97              : }
      98              : 
      99           39 : Address CcuRepAssign::GetAddrB()
     100              : {
     101           39 :     return addrB;
     102              : }
     103              : 
     104          352 : Variable CcuRepAssign::GetVarA()
     105              : {
     106          352 :     return varA;
     107              : }
     108              : 
     109          152 : Variable CcuRepAssign::GetVarB()
     110              : {
     111          152 :     return varB;
     112              : }
     113              : 
     114          196 : uint64_t CcuRepAssign::GetImmed()
     115              : {
     116          196 :     return immediate;
     117              : }
     118              : 
     119          681 : AssignSubType CcuRepAssign::GetSubType()
     120              : {
     121          681 :     return subType;
     122              : }
     123              : }; // namespace CcuRep
     124              : }; // namespace hcomm