IC知识积累——06_RISCV寄存器组的代码

最新推荐文章于 2023-09-27 00:00:48 发布
最新推荐文章于 2023-09-27 00:00:48 发布
阅读量436 收藏 1
点赞数 3
分类专栏： IC知识积累
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33766313/article/details/109841454
版权

RISCV寄存器组代码

// Copyright 2017 ETH Zurich and University of Bologna.
// Copyright and related rights are licensed under the Solderpad Hardware
// License, Version 0.51 (the \u201cLicense\u201d); you may not use this file except in
// compliance with the License.  You may obtain a copy of the License at
// http://solderpad.org/licenses/SHL-0.51. Unless required by applicable law
// or agreed to in writing, software, hardware and materials distributed under
// this License is distributed on an \u201cAS IS\u201d BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.


// Engineer:       Antonio Pullini - pullinia@iis.ee.ethz.ch                  //
//                                                                            //
// Additional contributions by:                                               //
//                 Sven Stucki - svstucki@student.ethz.ch                     //
//                 Michael Gautschi - gautschi@iis.ee.ethz.ch                 //
//                                                                            //
// Design Name:    RISC-V register file                                       //
// Project Name:   RI5CY                                                      //
// Language:       SystemVerilog                                              //
//                                                                            //
// Description:    Register file with 31x 32 bit wide registers. Register 0   //
//                 is fixed to 0. This register file is based on latches and  //
//                 is thus smaller than the flip-flop based register file.    //
//                 Also supports the fp-register file now if FPU=1            //
//                                                                            //


module riscv_register_file
#(
  parameter ADDR_WIDTH    = 5,
  parameter DATA_WIDTH    = 32,
  parameter FPU           = 0
)
(
  // Clock and Reset
  input  logic                   clk,
  input  logic                   rst_n,

  input  logic                   test_en_i,

  //Read port R1
  input  logic [ADDR_WIDTH-1:0]  raddr_a_i,
  output logic [DATA_WIDTH-1:0]  rdata_a_o,

  //Read port R2
  input  logic [ADDR_WIDTH-1:0]  raddr_b_i,
  output logic [DATA_WIDTH-1:0]  rdata_b_o,

  //Read port R3
  input  logic [ADDR_WIDTH-1:0]  raddr_c_i,
  output logic [DATA_WIDTH-1:0]  rdata_c_o,

  // Write port W1
  input  logic [ADDR_WIDTH-1:0]   waddr_a_i,
  input  logic [DATA_WIDTH-1:0]   wdata_a_i,
  input  logic                    we_a_i,

  // Write port W2
  input  logic [ADDR_WIDTH-1:0]   waddr_b_i,
  input  logic [DATA_WIDTH-1:0]   wdata_b_i,
  input  logic                    we_b_i
);

   // number of integer registers
   localparam    NUM_WORDS     = 2**(ADDR_WIDTH-1);
   // number of floating point registers
   localparam    NUM_FP_WORDS  = 2**(ADDR_WIDTH-1);
   localparam    NUM_TOT_WORDS = FPU ? NUM_WORDS + NUM_FP_WORDS : NUM_WORDS;
      
   // integer register file
   logic [DATA_WIDTH-1:0]         mem[NUM_WORDS];
   logic [NUM_TOT_WORDS-1:1]      waddr_onehot_a;
   logic [NUM_TOT_WORDS-1:1]      waddr_onehot_b, waddr_onehot_b_q;
   logic [NUM_TOT_WORDS-1:1]      mem_clocks;
   logic [DATA_WIDTH-1:0]         wdata_a_q;
   logic [DATA_WIDTH-1:0]         wdata_b_q;

   logic                          clk_int;

   // fp register file
   logic [DATA_WIDTH-1:0]         mem_fp[NUM_FP_WORDS];

   int                            unsigned i;
   int                            unsigned j;
   int                            unsigned k;
   int                            unsigned l;

   genvar                         x;
   genvar                         y;


   //-----------------------------------------------------------------------------
   //-- YSW ADD  : mem sigs test 
   //-----------------------------------------------------------------------------

   logic    [31:0]          mem_register_ila_0    ;
   logic    [31:0]          mem_register_ila_1    ;
   logic    [31:0]          mem_register_ila_2    ;
   logic    [31:0]          mem_register_ila_3    ;
   logic    [31:0]          mem_register_ila_4    ;
   logic    [31:0]          mem_register_ila_5    ;
   logic    [31:0]          mem_register_ila_6    ;
   logic    [31:0]          mem_register_ila_7    ;
   logic    [31:0]          mem_register_ila_8    ;
   logic    [31:0]          mem_register_ila_9    ;
   logic    [31:0]          mem_register_ila_10   ;
   logic    [31:0]          mem_register_ila_11   ;
   logic    [31:0]          mem_register_ila_12   ;
   logic    [31:0]          mem_register_ila_13   ;
   logic    [31:0]          mem_register_ila_14   ;
   logic    [31:0]          mem_register_ila_15   ;
   logic    [31:0]          mem_register_ila_16   ;
   logic    [31:0]          mem_register_ila_17   ;
   logic    [31:0]          mem_register_ila_18   ;
   logic    [31:0]          mem_register_ila_19   ;
   logic    [31:0]          mem_register_ila_20   ;
   logic    [31:0]          mem_register_ila_21   ;
   logic    [31:0]          mem_register_ila_22   ;
   logic    [31:0]          mem_register_ila_23   ;
   logic    [31:0]          mem_register_ila_24   ;
   logic    [31:0]          mem_register_ila_25   ;
   logic    [31:0]          mem_register_ila_26   ;
   logic    [31:0]          mem_register_ila_27   ;
   logic    [31:0]          mem_register_ila_28   ;
   logic    [31:0]          mem_register_ila_29   ;
   logic    [31:0]          mem_register_ila_30   ;
   logic    [31:0]          mem_register_ila_31   ;

   assign      mem_register_ila_0     =   mem[0 ]      ;
   assign      mem_register_ila_1     =   mem[1 ]      ;
   assign      mem_register_ila_2     =   mem[2 ]      ;
   assign      mem_register_ila_3     =   mem[3 ]      ;
   assign      mem_register_ila_4     =   mem[4 ]      ;
   assign      mem_register_ila_5     =   mem[5 ]      ;
   assign      mem_register_ila_6     =   mem[6 ]      ;
   assign      mem_register_ila_7     =   mem[7 ]      ;
   assign      mem_register_ila_8     =   mem[8 ]      ;
   assign      mem_register_ila_9     =   mem[9 ]      ;
   assign      mem_register_ila_10    =   mem[10]      ;
   assign      mem_register_ila_11    =   mem[11]      ;
   assign      mem_register_ila_12    =   mem[12]      ;
   assign      mem_register_ila_13    =   mem[13]      ;
   assign      mem_register_ila_14    =   mem[14]      ;
   assign      mem_register_ila_15    =   mem[15]      ;
   assign      mem_register_ila_16    =   mem[16]      ;
   assign      mem_register_ila_17    =   mem[17]      ;
   assign      mem_register_ila_18    =   mem[18]      ;
   assign      mem_register_ila_19    =   mem[19]      ;
   assign      mem_register_ila_20    =   mem[20]      ;
   assign      mem_register_ila_21    =   mem[21]      ;
   assign      mem_register_ila_22    =   mem[22]      ;
   assign      mem_register_ila_23    =   mem[23]      ;
   assign      mem_register_ila_24    =   mem[24]      ;
   assign      mem_register_ila_25    =   mem[25]      ;
   assign      mem_register_ila_26    =   mem[26]      ;
   assign      mem_register_ila_27    =   mem[27]      ;
   assign      mem_register_ila_28    =   mem[28]      ;
   assign      mem_register_ila_29    =   mem[29]      ;
   assign      mem_register_ila_30    =   mem[30]      ;
   assign      mem_register_ila_31    =   mem[31]      ;
   //-----------------------------------------------------------------------------
   //-- READ : Read address decoder RAD
   //-----------------------------------------------------------------------------
   if (FPU == 1) begin
      assign rdata_a_o = raddr_a_i[5] ? mem_fp[raddr_a_i[4:0]] : mem[raddr_a_i[4:0]];
      assign rdata_b_o = raddr_b_i[5] ? mem_fp[raddr_b_i[4:0]] : mem[raddr_b_i[4:0]];
      assign rdata_c_o = raddr_c_i[5] ? mem_fp[raddr_c_i[4:0]] : mem[raddr_c_i[4:0]];
   end else begin
      assign rdata_a_o = mem[raddr_a_i[4:0]];
      assign rdata_b_o = mem[raddr_b_i[4:0]];
      assign rdata_c_o = mem[raddr_c_i[4:0]];
   end     

   //-----------------------------------------------------------------------------
   // WRITE : SAMPLE INPUT DATA
   //---------------------------------------------------------------------------

   cluster_clock_gating CG_WE_GLOBAL
     (
      .clk_i     ( clk             ),
      .en_i      ( we_a_i | we_b_i ),
      .test_en_i ( test_en_i       ),
      .clk_o     ( clk_int         )
      );

   // use clk_int here, since otherwise we don't want to write anything anyway
   always_ff @(posedge clk_int, negedge rst_n)
     begin : sample_waddr
        if (~rst_n) begin
           wdata_a_q        <= '0;
           wdata_b_q        <= '0;
           waddr_onehot_b_q <= '0;
        end else begin
           if(we_a_i)
             wdata_a_q <= wdata_a_i;

           if(we_b_i)
             wdata_b_q <= wdata_b_i;

           waddr_onehot_b_q <= waddr_onehot_b;
        end
     end

   //-----------------------------------------------------------------------------
   //-- WRITE : Write Address Decoder (WAD), combinatorial process
   //-----------------------------------------------------------------------------
   always_comb
     begin : p_WADa
        for(i = 1; i < NUM_TOT_WORDS; i++)
          begin : p_WordItera
             if ( (we_a_i == 1'b1 ) && (waddr_a_i == i) )
               waddr_onehot_a[i] = 1'b1;
             else
               waddr_onehot_a[i] = 1'b0;
          end
     end

   always_comb
     begin : p_WADb
        for(j = 1; j < NUM_TOT_WORDS; j++)
          begin : p_WordIterb
             if ( (we_b_i == 1'b1 ) && (waddr_b_i == j) )
               waddr_onehot_b[j] = 1'b1;
             else
               waddr_onehot_b[j] = 1'b0;
          end
     end

   //-----------------------------------------------------------------------------
   //-- WRITE : Clock gating (if integrated clock-gating cells are available)
   //-----------------------------------------------------------------------------
   generate
      for(x = 1; x < NUM_TOT_WORDS; x++)
        begin : CG_CELL_WORD_ITER
           cluster_clock_gating CG_Inst
             (
              .clk_i     ( clk_int                               ),
              .en_i      ( waddr_onehot_a[x] | waddr_onehot_b[x] ),
              .test_en_i ( test_en_i                             ),
              .clk_o     ( mem_clocks[x]                         )
              );
        end
   endgenerate
   
   //-----------------------------------------------------------------------------
   //-- WRITE : Write operation
   //-----------------------------------------------------------------------------
   //-- Generate M = WORDS sequential processes, each of which describes one
   //-- word of the memory. The processes are synchronized with the clocks
   //-- ClocksxC(i), i = 0, 1, ..., M-1
   //-- Use active low, i.e. transparent on low latches as storage elements
   //-- Data is sampled on rising clock edge

   // Integer registers
   always_latch
     begin : latch_wdata
        // Note: The assignment has to be done inside this process or Modelsim complains about it
        mem[0] = '0;

        for(k = 1; k < NUM_WORDS; k++)
          begin : w_WordIter
             if(mem_clocks[k] == 1'b1)
               mem[k] = waddr_onehot_b_q[k] ? wdata_b_q : wdata_a_q;
          end
     end
   
   if (FPU == 1) begin
   // Floating point registers
   always_latch
     begin : latch_wdata_fp
        if (FPU == 1) begin
           for(l = 0; l < NUM_FP_WORDS; l++)
             begin : w_WordIter
                if(mem_clocks[l+NUM_WORDS] == 1'b1)
                  mem_fp[l] = waddr_onehot_b_q[l+NUM_WORDS] ? wdata_b_q : wdata_a_q;
             end
        end
     end
   end
endmodule

其中包含了各种技巧：
1、用parameter常数来控制assign的选取：

   //-----------------------------------------------------------------------------
   //-- READ : Read address decoder RAD
   //-----------------------------------------------------------------------------
   if (FPU == 1) begin
      assign rdata_a_o = raddr_a_i[5] ? mem_fp[raddr_a_i[4:0]] : mem[raddr_a_i[4:0]];
      assign rdata_b_o = raddr_b_i[5] ? mem_fp[raddr_b_i[4:0]] : mem[raddr_b_i[4:0]];
      assign rdata_c_o = raddr_c_i[5] ? mem_fp[raddr_c_i[4:0]] : mem[raddr_c_i[4:0]];
   end else begin
      assign rdata_a_o = mem[raddr_a_i[4:0]];
      assign rdata_b_o = mem[raddr_b_i[4:0]];
      assign rdata_c_o = mem[raddr_c_i[4:0]];
   end

2、时钟门控原语，可用于时钟的暂停于信号采样

 //-----------------------------------------------------------------------------
   // WRITE : SAMPLE INPUT DATA
   //---------------------------------------------------------------------------

   cluster_clock_gating CG_WE_GLOBAL
     (
      .clk_i     ( clk             ),
      .en_i      ( we_a_i | we_b_i ),
      .test_en_i ( test_en_i       ),
      .clk_o     ( clk_int         )
      );

   // use clk_int here, since otherwise we don't want to write anything anyway
   always_ff @(posedge clk_int, negedge rst_n)
     begin : sample_waddr
        if (~rst_n) begin
           wdata_a_q        <= '0;
           wdata_b_q        <= '0;
           waddr_onehot_b_q <= '0;
        end else begin
           if(we_a_i)
             wdata_a_q <= wdata_a_i;

           if(we_b_i)
             wdata_b_q <= wdata_b_i;

           waddr_onehot_b_q <= waddr_onehot_b;
        end
     end

3、for循环的使用

   //-----------------------------------------------------------------------------
   //-- WRITE : Write Address Decoder (WAD), combinatorial process
   //-----------------------------------------------------------------------------
   always_comb
     begin : p_WADa
        for(i = 1; i < NUM_TOT_WORDS; i++)
          begin : p_WordItera
             if ( (we_a_i == 1'b1 ) && (waddr_a_i == i) )
               waddr_onehot_a[i] = 1'b1;
             else
               waddr_onehot_a[i] = 1'b0;
          end
     end

   always_comb
     begin : p_WADb
        for(j = 1; j < NUM_TOT_WORDS; j++)
          begin : p_WordIterb
             if ( (we_b_i == 1'b1 ) && (waddr_b_i == j) )
               waddr_onehot_b[j] = 1'b1;
             else
               waddr_onehot_b[j] = 1'b0;
          end
     end

   //-----------------------------------------------------------------------------
   //-- WRITE : Clock gating (if integrated clock-gating cells are available)
   //-----------------------------------------------------------------------------
   generate
      for(x = 1; x < NUM_TOT_WORDS; x++)
        begin : CG_CELL_WORD_ITER
           cluster_clock_gating CG_Inst
             (
              .clk_i     ( clk_int                               ),
              .en_i      ( waddr_onehot_a[x] | waddr_onehot_b[x] ),
              .test_en_i ( test_en_i                             ),
              .clk_o     ( mem_clocks[x]                         )
              );
        end
   endgenerate
俺是菜鸡
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【RISC-V】RISC-V寄存器
qq_43194080的博客
08-28 5586
【代码】【RISC-V】RISC-V寄存器简介。
RISCV CSR寄存器对应机器码
HGGshiwo的博客
08-24 1452
RISC-V反汇编显示原始指令和寄存器编号
zoomdy's blog
10-09 8344
反汇编时添加 `-M no-aliases,numeric`选项，输出原始指令和寄存器编号。
通用寄存器组
10-31
通用寄存器组，完成对输入字符的存储并输出
RISC-V 整型通用寄存器介绍
17岁boy的博客
08-17 2532
x0/zerox0寄存器又被称为zero寄存器，它的读写是无效的，它的值只能为0，这是为了让编译器进行优化上面这段汇编的作用是进行相加运算，将x2和x3寄存器的值相加的结果并放入x1寄存器，但是如果x3寄存器的值为0当RISC-V处理器执行这条指令的时不会去读取x0寄存器的值，会直接按0来运算，这样就可以省去与0做运算时读取的步骤。RISC-V处理器在设计时只要涉及到x0寄存器的读取一律按0来处理不会去读取x0的寄存器，这么做的目的是为了方便编译器优化某些运算。
sifive_RISCV_开源verilog代码
08-24
在sifive_RISCV_开源verilog代码中，Verilog被用来描述RISC-V核心的逻辑电路，包括寄存器、算术逻辑单元（ALU）、分支预测、内存接口等组件。这些组件组合起来，形成了一个完整的RISC-V处理器核心。 sifive_E31_...
riscv-spec-v2.2（指令集架构文档）.zip_RISCV_riscv set指令_riscv指令_指令集_精简指令集
07-14
在《riscv-spec-v2.2》文档中，你会找到关于RISC-V指令格式、寻址模式、寄存器分配、异常处理、特权级别、中断和调试支持等详细信息。通过深入阅读这份文档，开发者和硬件设计师可以全面理解如何编写兼容RISC-V的...
gpr.zip_32位堆寄存器_gpr 寄存器_gpr寄存器_savegpr_27_寄存器堆
09-21
"gpr.zip_32位堆寄存器_gpr寄存器_gpr寄存器_savegpr_27_寄存器堆"这个标题涉及到的核心概念是通用寄存器（General Purpose Registers，简称GPRs）和32位寄存器堆。 首先，我们来详细了解一下32位堆寄存器。在...
以太网PHY寄存器分析.zip_childrenr1l_phy 寄存器_phy寄存器_以太网 PHY 寄存器_以太网phy
07-14
以太网PHY（Physical Layer，物理层）是网络通信中数据传输的基础，它负责将数字信号转换为可以在物理介质上...无论是对于设备制造商还是网络运维人员，理解这些知识都至关重要，因为它直接影响到网络的稳定性和效率。
ADC.rar_dsp adc寄存器_dspadc寄存器
09-19
**ADC（模数转换器）在DSP中的应用与寄存器配置** 在数字信号处理（DSP）领域，ADC（模拟到数字转换器）是至关重要的组成部分，它将连续的模拟信号转换为离散的数字信号，以便进行后续的数字处理。在本案例中，我们...
设计一个通用寄存器组，16位的寄存器。（含报告）
01-09
设计一个通用寄存器组，满足以下要求： ①通用寄存器组中有4个16位的寄存器。 ②当复位信号reset=0时，将通用寄存器组中的4个寄存器清零。 ③通用寄存器组中有1个写入端口，当DRWr=1时，在时钟clk的上升沿将数据总线上的数据写入DR[1..0]指定的寄存器。 ④通用寄存器组中有两个读出端口，由控制信IDC控制，分别对应算术逻辑单元的A口和B口。IDC=0选择目的操作数；IDC=1选择源操作数。 ⑤设计要求层次设计。底层的设计实体有3个：通用寄存器组数据输入模块包括4个16位寄存器，具有复位功能和允许写功能；一个4选1多路开关，负责选择寄存器的读出。一个2路数据分配器实现数据双端口输出，顶层设计构成一个完整的通用寄存器组。
riscv-asm:risc-v汇编语言
03-19
Tcl中的risc-v汇编程序 这个简单的risc-v汇编程序支持带有几个标准扩展的rv32和rv64。它的输出是一个原始列表，列出了源代码行，地址和字节（以十六进制表示）。当前不支持编写ELF。 指令集和扩展名： rv32G（IMAFD_Zicsr_Zifencei） rv64G（IMAFD_Zicsr_Zifencei） C-压缩指令 E-16寄存器 Q-四重浮子 Zfinx-X寄存器中的浮点数 其中包含一个非常简单的example.rva。尝试make example $ make example ./rva.tcl -march rv32gc example.rva 00005 0100 00C58533 add a0 a1 a2 00006 0104 FFFFC297 auipc t0 top 00006 0108 12E1 addi t0 t0
Ibex 是一个小型 32 位 RISC-V CPU 内核，以前称为 zero-riscy_SystemVeri_代码_下载
07-04
bex 是用 SystemVerilog 编写的生产级开源 32 位 RISC-V CPU 内核。CPU 内核高度可参数化，非常适合嵌入式控制应用。Ibex 正在接受广泛的验证，并且已经看到多个流片。Ibex 支持整数 (I) 或嵌入式 (E)、整数乘除法 (M)、压缩 (C) 和 B（位操作）扩展。 下面的框图显示了带有 2 级流水线的小参数化。 Ibex 最初是作为PULP 平台的一部分以“零风险” 的名义开发的，并已贡献给lowRISC，后者对其进行维护和进一步开发。它正在积极开发中。 配置 Ibex 提供了多种配置参数，以满足各种应用场景的需求。这些选项包括乘法器单元架构的不同选择，以及一系列性能和安全特性。下表显示了一些选定配置的性能、面积和验证状态。这些是 lowRISC 专注于性能评估和设计验证的配置（请参阅支持的配置）。 更多详情、使用方法，请下载后阅读README.md文件
汇编-寄存器组
杀出条血路来
10-18 194
寄存器组 一、寄存器组 数据寄存器、指针寄存器和变址寄存器称为通用寄存器，除了各自规定的专门用途之外，还可以用于传送和暂存数据，可以保存算术逻辑运算中的操作数和运算结果。 通用寄存器专门用途： 8086/8088CPU的四个段寄存器均是16位的，分别称为代码段，数据段，堆栈段和附加段寄存器组。依赖这四个段寄存器实现寻址1M字节物理地址空间。相应的也有四个段：代码段，数据段，堆栈段和...
RISC-V学习笔记（二）：RISC-V寄存器和指令系统
weixin_75067193的博客
09-27 1303
摆烂才是王道
RISC-V单周期处理器设计（寄存器堆设计）（三）
小张爱学习哦的博客
03-23 3317
RISC-V寄存器堆设计
寄存器组
huangwei.pro
01-29 3546
2.1 寄存器组寄存器是CPU内部重要的数据存储资源，是汇编程序员能直接使用的硬件资源之一。由于寄存器的存取速度比内存快，所以，在用汇编语言编写程序时，要尽可能充分利用寄存器的存储功能。寄存器一般用来保存程序的中间结果，为随后的指令快速提供操作数，从而避免把中间结果存入内存，再读取内存的操作。在高级语言(如：C/C++语言)中，也有定义变量为寄存器类型的，这就是提高寄存器利用率的一种可行的
PC寄存器
DimplesLee的博客
11-25 320
TinyRISC-V 处理器，PC寄存器。注意：个人学习笔记，参考​ 《从零开始写RISC-V处理器》
7. 自制操作系统: risc-v 通用寄存器
Do one thing at a time, and do well.
03-07 2942
RISC-V基础ISA由31个用于保存整数值的通用寄存器x1-x31组成。寄存器x0固定连接到常数0。还有一个额外的用户可见程序计数器pc寄存器，它保存当前指令的地址。RISC-V没有定义一个特定的子例程返回地址链接寄存器，但它确实建议标准软件调用约定应该使用寄存器x1来存储调用的返回地址。这些寄存器的宽度由使用的RISC-V基变量定义。也就是说，对于RV32，寄存器是32位宽，对于RV64，寄存器是64位宽 调用惯例 在传统的RISC-V软件中，堆栈向下增长，堆栈指针总是16字节对齐。
FLASH_PUKR寄存器
最新发布
04-13
FLASH_PUKR寄存器是Flash编程寄存器，用于控制和管理Flash存储器的编程过程。它通常在嵌入式系统中使用，用于微控制器或处理器中控制Flash芯片的编程。 FLASH_PUKR寄存器具有一些特性和位定义，以便根据需要控制...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

俺是菜鸡

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值