riscv pipelined

//instancia no module riscv:
  hazard_detection_unit hdu(
    .ResultSrcEb0(ResultSrcEb0),
    .PCSrcE(PCSrcE),
    .Rs1D(Rs1D), .Rs2D(Rs2D), .RdE(RdE),
    .StallF(StallF), .StallD(StallD),
    .FlushD(FlushD), .FlushE(FlushE)
  );

  forwarding_unit fu(
    .RegWriteM(RegWriteM), .RegWriteW(RegWriteW),
    .Rs1E(Rs1E), .Rs2E(Rs2E),
    .RdM(RdM), .RdW(RdW),
    .ForwardAE(ForwardAE), .ForwardBE(ForwardBE)
  );

//modulo no final do código:

// Unidade de detecção de hazards (stall e flushes)
module hazard_detection_unit(
    //Indica se a instrução em execução é um LW (ResultScrE[0] == 1)
    input logic ResultSrcEb0,
    //indica se um desvio (beq ou jal) foi tomado na EXE
    input logic PCSrcE,
    //registradores fonte da instrução na fase de decode
    input logic [4:0] Rs1D, Rs2D,
    //registrador destino da instrução na fase de execute (possível load)
    input logic [4:0] RdE,
    output logic StallF, //sinal para travar o estágio de fetch
    output logic StallD, //sinal para travar o estágio decode
    output logic FlushD, //sinal para limpar o estágio de decode
    output logic FlushE //sinal para limpar o estágio de execute
);

  logic lwStall; // true se há dependência com instrução LW na fase E

  // Detecta hazard do tipo load-use: se a instrução que está em EXE for um LW
  // e a próxima instrução (em Decode) precisar do resultado (usa Rs1 ou Rs2)
  assign lwStall = ResultSrcEb0 && (RdE != 0) &&
                   (RdE == Rs1D || RdE == Rs2D);

  // Se hazard for detectado, estagna Fetch e Decode
  assign StallF = lwStall;
  assign StallD = lwStall;

  // Se um desvio (branch) foi tomado, precisamos limpar a próxima instrução
  assign FlushD = PCSrcE;

  // Precisamos limpar o estágio EXE em caso de load-use hazard ou branch
  assign FlushE = lwStall || PCSrcE;

endmodule

// Unidade de forwarding (encaminhamento) para evitar dependências RAW (Read After Write)
module forwarding_unit(
  input  logic        RegWriteM,    // MEM → WB: se a instrução da fase MEM escreve no registrador
  input  logic        RegWriteW,    // WB: se a instrução da fase WB escreve no registrador
  input  logic [4:0]  Rs1E, Rs2E,   // Registradores fonte da instrução em execução (EXE)
  input  logic [4:0]  RdM, RdW,     // Registradores destino nas fases MEM e WB
  output logic [1:0]  ForwardAE,    // Seletor para encaminhamento de A (SrcA)
  output logic [1:0]  ForwardBE     // Seletor para encaminhamento de B (SrcB)
);

  always_comb begin
    // Inicialmente, nenhum encaminhamento
    ForwardAE = 2'b00;
    ForwardBE = 2'b00;

    // Encaminhamento para SrcA:
    // 2'b10 = valor vindo da fase MEM (ALUResultM)
    if (RegWriteM && (RdM != 0) && (RdM == Rs1E))
      ForwardAE = 2'b10;

    // 2'b01 = valor vindo da fase WB (ResultW)
    else if (RegWriteW && (RdW != 0) && (RdW == Rs1E))
      ForwardAE = 2'b01;

    // Encaminhamento para SrcB:
    // 2'b10 = valor vindo da fase MEM (ALUResultM)
    if (RegWriteM && (RdM != 0) && (RdM == Rs2E))
      ForwardBE = 2'b10;

    // 2'b01 = valor vindo da fase WB (ResultW)
    else if (RegWriteW && (RdW != 0) && (RdW == Rs2E))
      ForwardBE = 2'b01;
  end

endmodule