inefficient rv32i multiply by 10 ?

[alex-s168]

https://godbolt.org/z/Y4MzcY33n

the code generates a call to __mulsi3, which is definitely slower than (x << 3) + (x << 1).

is there any specific reason for this?

[llvmbot]

@llvm/issue-subscribers-backend-risc-v

Author: alex_s168 (alex-s168)

https://godbolt.org/z/Y4MzcY33n

the code generates a call to __mulsi3, which is definitely slower than (x << 3) + (x << 1).

is there any specific reason for this?

[topperc]

is there any specific reason for this?

LLVM doesn't have any general code for decomposing a multiply by constant and no one has written one for RISC-V.

I think the only decomposition code is this in DAGCombiner.cpp which has a TODO on it for generalization.

  if (!UseVP && N1IsConst &&                                                     
      TLI.decomposeMulByConstant(*DAG.getContext(), VT, N1)) {                   
    // TODO: We could handle more general decomposition of any constant by       
    //       having the target set a limit on number of ops and making a         
    //       callback to determine that sequence (similar to sqrt expansion).    
    unsigned MathOp = ISD::DELETED_NODE;                                         
    APInt MulC = ConstValue1.abs();                                              
    // The constant `2` should be treated as (2^0 + 1).                          
    unsigned TZeros = MulC == 2 ? 0 : MulC.countr_zero();                        
    MulC.lshrInPlace(TZeros);                                                    
    if ((MulC - 1).isPowerOf2())                                                 
      MathOp = ISD::ADD;                                                         
    else if ((MulC + 1).isPowerOf2())                                            
      MathOp = ISD::SUB;                                                         
                                                                                 
    if (MathOp != ISD::DELETED_NODE) {                                           
      unsigned ShAmt =                                                           
          MathOp == ISD::ADD ? (MulC - 1).logBase2() : (MulC + 1).logBase2();    
      ShAmt += TZeros;                                                           
      assert(ShAmt < BitWidth &&                                                 
             "multiply-by-constant generated out of bounds shift");              
      SDValue Shl =                                                              
          DAG.getNode(ISD::SHL, DL, VT, N0, DAG.getConstant(ShAmt, DL, VT));     
      SDValue R =                                                                
          TZeros ? DAG.getNode(MathOp, DL, VT, Shl,                              
                               DAG.getNode(ISD::SHL, DL, VT, N0,                 
                                           DAG.getConstant(TZeros, DL, VT)))     
                 : DAG.getNode(MathOp, DL, VT, Shl, N0);                         
      if (ConstValue1.isNegative())                                              
        R = DAG.getNegative(R, DL, VT);                                          
      return R;                                                                  
    }                                                                            
  } 

[efriedma-quic]

There's some code in the Mips backend that does generalized decomposition of multiplies; see genConstMult in llvm/lib/Target/Mips/MipsSEISelLowering.cpp .