Complete generateComputeFun.

Author: sletz

compiler/generator/instructions.hh

@@ -2616,6 +2616,15 @@ struct IB {
         return genForLoopInst(dec, end, inc);
     }
 
+    static ForLoopInst* genForLoopInst(const std::string& index, int init, ValueInst* size,
+                                       int step = 1)
+    {
+        DeclareVarInst* dec = genDecLoopVar(index, genInt32Typed(), genInt32NumInst(init));
+        ValueInst*      end = genLessThan(dec->load(), size);
+        StoreVarInst*   inc = dec->store(genAdd(dec->load(), step));
+        return genForLoopInst(dec, end, inc);
+    }
+
     // Used for Rust backend
     static SimpleForLoopInst* genSimpleForLoopInst(const std::string& name, ValueInst* upperBound,
                                                    ValueInst* lowerBound = new Int32NumInst(0),
@@ -3373,15 +3382,21 @@ struct IB {
 
     static DeclareFunInst* generateComputeFun(const std::string& name, const std::string& obj,
                                               bool ismethod, bool isvirtual,
-                                              BlockInst* compute_block)
+                                              BlockInst* control_block, BlockInst* sample_block)
     {
         Names args = genMethod(obj, ismethod);
         args.push_back(genNamedTyped("count", Typed::kInt32));
         args.push_back(genNamedTyped("inputs", Typed::kFloatMacro_ptr_ptr));
         args.push_back(genNamedTyped("outputs", Typed::kFloatMacro_ptr_ptr));
 
-        // Explicit return
-        compute_block->pushBackInst(genRetInst());
+        // Control rate code
+        BlockInst* compute_block = genBlockInst();
+        compute_block->pushBackInst(control_block);
+
+        // Sample rate code
+        ForLoopInst* loop = genForLoopInst("i", 0, genLoadFunArgsVar("count"), 1);
+        loop->pushBackInst(sample_block);
+        compute_block->pushBackInst(loop);
 
         // Creates function
         return IB::genVoidFunction(name, args, compute_block, isvirtual);

compiler/generator/instructions_compiler.cpp

@@ -109,7 +109,7 @@ Tree InstructionsCompiler::prepare(Tree LS)
         throw faustexception("Dump signal type finished...\n");
     } else if (gGlobal->gDumpNorm == 3) {
         SignalFIRCompiler fir_compiler(fContainer->inputs(), fContainer->outputs(), L1);
-        dump2FIR(fir_compiler.genFIRModule());
+        // dump2FIR(fir_compiler.genFIRModule());
         ModuleInst* fir_module = fir_compiler.genFIRModule();
 
         std::stringstream cpp_stream;

compiler/transform/signalFIRCompiler.cpp

@@ -110,22 +110,16 @@ void SignalFIRCompiler::visit(Tree sig)
     if (xtended* xt = (xtended*)getUserData(sig)) {
         list<ValueInst*>       args;
         vector<Typed::VarType> atypes;
-        // Compile all arguments then compile the function call
+        int rtype = getCertifiedSigType(sig)->nature();
+        // Compiles all arguments
         for (Tree b : sig->branches()) {
             self(b);
             args.push_back(popRes());
             atypes.push_back(convert2FIRType(getCertifiedSigType(b)->nature()));
         }
-
-        // ValueInst* res = xt->compute(args);
-
-        //  HACK: for 'min/max' res may actually be of type kInt
-        int rtype = getCertifiedSigType(sig)->nature();
-
-        // Compile the function declaration
+        // Compiles the function declaration
         fGlobalBlock->pushBackInst(IB::genFunction(xt->name(), convert2FIRType(rtype), atypes));
-        // pushRes((rtype == kInt) ? Node(int(res.getDouble())) : res);
-        // Compile the function call
+        // Compiles the function call
         pushRes(IB::genFunCallInst(xt->name(), args));
 
     } else if (isSigInt(sig, &i_val)) {
@@ -376,6 +370,7 @@ void SignalFIRCompiler::compile()
     while (!isNil(output_list)) {
         // Compile each output
         Tree out_sig = hd(output_list);
+        // std::cerr << "compile " << ppsig(out_sig) << std::endl;
         self(out_sig);
         // Get compiled value and sotre in the output
         ValueInst* res = popRes();
@@ -465,8 +460,9 @@ void SignalFIRCompiler::initTables()
  */
 ModuleInst* SignalFIRCompiler::genFIRModule()
 {
-    // Compile ouputs signals to FIR
+    // Compile tables
     initTables();
+    // Compile outputs signals to FIR
     compile();
 
     // Create the FIR module using the generated FIR blocks
@@ -490,7 +486,10 @@ ModuleInst* SignalFIRCompiler::genFIRModule()
         IB::generateInstanceClear("instanceClear", "", true, true, fClearBlock));
 
     // Compute
-    fir_module->pushFunction(IB::generateComputeFun("compute", "", true, true, fComputeBlock));
+    dump2FIR(fControlBlock);
+    dump2FIR(fSampleBlock);
+    fir_module->pushFunction(
+        IB::generateComputeFun("compute", "", true, true, fControlBlock, fSampleBlock));
 
     return fir_module;
 }

compiler/transform/signalFIRCompiler.hh

@@ -67,7 +67,7 @@ inline BasicTyped* genBasicTyped(Tree sig)
  *   **fResetBlock**    — code executed once in the instanceResetUserInterface
  *   **fClearBlock**    — code executed once in the instanceClear
  *   **fControlBlock**  — per‑block computations done in `compute` function before the DSP loop
- *   **fComputeBlock**  — the per‑sample DSP body done in `compute`function
+ *   **fSampleBlock**   — the per‑sample DSP body done in `compute`function
  *
  * During construction the compiler:
  *   1. Runs a `SignalBuilder` pass that allocates every resource
@@ -629,7 +629,7 @@ struct SignalFIRCompiler : public SignalVisitor {
     BlockInst* fResetBlock;    // Code executed to reset DSP state (delays, tables, etc.)
     BlockInst* fClearBlock;    // Code for clearing memory (if required by certain data structures)
     BlockInst* fControlBlock;  // Code executed to update UI controls (sliders, buttons, etc.)
-    BlockInst* fComputeBlock;  // Main compute block executed at every sample frame
+    BlockInst* fSampleBlock;   // Main compute block executed at every sample frame
 
     std::stack<ValueInst*>     fValueStack;  // Compiler's value stack used during signal traversal
     std::map<Tree, DelayedSig> fDelays;      // Mapping between signals and their delay buffers
@@ -652,8 +652,8 @@ struct SignalFIRCompiler : public SignalVisitor {
         fResetBlock   = IB::genBlockInst();
         fClearBlock   = IB::genBlockInst();
         fControlBlock = IB::genBlockInst();
-        fComputeBlock = IB::genBlockInst();
-    
+        fSampleBlock  = IB::genBlockInst();
+
         // Prepare the signal compilation context
         // The SignalBuilder populates:
         //  - Delay lines (fDelays)
@@ -673,7 +673,7 @@ struct SignalFIRCompiler : public SignalVisitor {
      * @brief Dispatch a write statement to the appropriate DSP code block.
      *
      * This method routes a generated `StatementInst` (such as an assignment or store)
-     * to the correct code block (`fInitBlock`, `fControlBlock`, or `fComputeBlock`)
+     * to the correct code block (`fInitBlock`, `fControlBlock`, or `fSampleBlock`)
      * based on the variability (lifetime) of the signal associated with `x`.
      *
      * Variability levels:
@@ -697,7 +697,7 @@ struct SignalFIRCompiler : public SignalVisitor {
                 fControlBlock->pushBackInst(val);
                 break;
             case kSamp:
-                fComputeBlock->pushBackInst(val);
+                fSampleBlock->pushBackInst(val);
                 break;
             default:
                 faustassert(false);