da4ml 0.5.0__cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

da4ml/codegen/hls/source/ap_types/hls_math.h

@@ -0,0 +1,27 @@
+#ifndef X_HLS_MATH_H
+#define X_HLS_MATH_H
+
+#include <cmath>
+#include "ap_fixed.h"
+
+namespace hls {
+
+template<class T>
+static T exp(const T x) {
+  return (T) std::exp(x.to_double());
+}
+
+template <typename T> T sin(T x) { return (T) std::sin(x.to_double()); };
+
+template <typename T> T cos(T x) { return (T) std::cos(x.to_double()); };
+
+template <typename T> T asin(T x) { return (T) std::asin(x.to_double()); };
+
+template <typename T> T acos(T x) { return (T) std::acos(x.to_double()); };
+
+template <typename T> T atan(T x) { return (T) std::atan(x.to_double()); };
+
+template <typename T> T atan2(T x, T y) { return (T) hls::atan2(x.to_double(), y.to_double()); };
+
+}
+#endif

da4ml/codegen/hls/source/ap_types/hls_stream.h

@@ -0,0 +1,263 @@
+/*
+#-  (c) Copyright 2011-2018 Xilinx, Inc. All rights reserved.
+#-
+#-  This file contains confidential and proprietary information
+#-  of Xilinx, Inc. and is protected under U.S. and
+#-  international copyright and other intellectual property
+#-  laws.
+#-
+#-  DISCLAIMER
+#-  This disclaimer is not a license and does not grant any
+#-  rights to the materials distributed herewith. Except as
+#-  otherwise provided in a valid license issued to you by
+#-  Xilinx, and to the maximum extent permitted by applicable
+#-  law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
+#-  WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
+#-  AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
+#-  BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
+#-  INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
+#-  (2) Xilinx shall not be liable (whether in contract or tort,
+#-  including negligence, or under any other theory of
+#-  liability) for any loss or damage of any kind or nature
+#-  related to, arising under or in connection with these
+#-  materials, including for any direct, or any indirect,
+#-  special, incidental, or consequential loss or damage
+#-  (including loss of data, profits, goodwill, or any type of
+#-  loss or damage suffered as a result of any action brought
+#-  by a third party) even if such damage or loss was
+#-  reasonably foreseeable or Xilinx had been advised of the
+#-  possibility of the same.
+#-
+#-  CRITICAL APPLICATIONS
+#-  Xilinx products are not designed or intended to be fail-
+#-  safe, or for use in any application requiring fail-safe
+#-  performance, such as life-support or safety devices or
+#-  systems, Class III medical devices, nuclear facilities,
+#-  applications related to the deployment of airbags, or any
+#-  other applications that could lead to death, personal
+#-  injury, or severe property or environmental damage
+#-  (individually and collectively, "Critical
+#-  Applications"). Customer assumes the sole risk and
+#-  liability of any use of Xilinx products in Critical
+#-  Applications, subject only to applicable laws and
+#-  regulations governing limitations on product liability.
+#-
+#-  THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
+#-  PART OF THIS FILE AT ALL TIMES. 
+#- ************************************************************************
+
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" 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.
+*/
+
+#ifndef X_HLS_STREAM_SIM_H
+#define X_HLS_STREAM_SIM_H
+
+/*
+ * This file contains a C++ model of hls::stream.
+ * It defines C simulation model.
+ */
+#ifndef __cplusplus
+
+#error C++ is required to include this header file
+
+#else
+
+//////////////////////////////////////////////
+// C level simulation models for hls::stream
+//////////////////////////////////////////////
+#include <queue>
+#include <iostream>
+#include <typeinfo>
+#include <string>
+#include <sstream>
+
+#ifdef HLS_STREAM_THREAD_SAFE
+#include <mutex>
+#include <condition_variable>
+#endif
+
+#ifndef _MSC_VER
+#include <cxxabi.h>
+#include <stdlib.h>
+#endif
+
+namespace hls {
+
+template<typename __STREAM_T__>
+class stream
+{
+  protected:
+    std::string _name;
+    std::deque<__STREAM_T__> _data; // container for the elements
+#ifdef HLS_STREAM_THREAD_SAFE
+    std::mutex _mutex;
+    std::condition_variable _condition_var;
+#endif    
+
+  public:
+    /// Constructors
+    // Keep consistent with the synthesis model's constructors
+    stream() {
+        static unsigned _counter = 1;
+        std::stringstream ss;
+#ifndef _MSC_VER
+        char* _demangle_name = abi::__cxa_demangle(typeid(*this).name(), 0, 0, 0);
+        if (_demangle_name) {
+            _name = _demangle_name;
+            free(_demangle_name);
+        }
+        else {
+            _name = "hls_stream";
+        }
+#else
+        _name = typeid(*this).name();
+#endif
+
+        ss << _counter++;
+        _name += "." + ss.str();
+    }
+
+    stream(const std::string name) {
+    // default constructor,
+    // capacity set to predefined maximum
+        _name = name;
+    }
+
+  /// Make copy constructor and assignment operator private
+  private:
+    stream(const stream< __STREAM_T__ >& chn):
+        _name(chn._name), _data(chn._data) {
+    }
+
+    stream& operator = (const stream< __STREAM_T__ >& chn) {
+        _name = chn._name;
+        _data = chn._data;
+        return *this;
+    }
+
+  public:
+    /// Overload >> and << operators to implement read() and write()
+    void operator >> (__STREAM_T__& rdata) {
+        read(rdata);
+    }
+
+    void operator << (const __STREAM_T__& wdata) {
+        write(wdata);
+    }
+
+
+  public:
+    /// Destructor
+    /// Check status of the queue
+    virtual ~stream() {
+        if (!_data.empty())
+        {
+            std::cout << "WARNING: Hls::stream '" 
+                      << _name 
+                      << "' contains leftover data,"
+                      << " which may result in RTL simulation hanging."
+                      << std::endl;
+        }
+    }
+
+    /// Status of the queue
+    bool empty() {
+#ifdef HLS_STREAM_THREAD_SAFE
+        std::lock_guard<std::mutex> lg(_mutex);
+#endif
+        return _data.empty();
+    }    
+
+    bool full() const { return false; }
+
+    /// Blocking read
+    void read(__STREAM_T__& head) {
+        head = read();
+    }
+
+#ifdef HLS_STREAM_THREAD_SAFE
+    __STREAM_T__ read() {
+        std::unique_lock<std::mutex> ul(_mutex);
+        while (_data.empty()) {
+            _condition_var.wait(ul);
+        }
+
+        __STREAM_T__ elem;
+        elem = _data.front();
+        _data.pop_front();
+        return elem;
+    }
+#else
+    __STREAM_T__ read() {
+        __STREAM_T__ elem;
+        if (_data.empty()) {
+            std::cout << "WARNING: Hls::stream '"
+                      << _name 
+                      << "' is read while empty,"
+                      << " which may result in RTL simulation hanging."
+                      << std::endl;
+            elem = __STREAM_T__();
+        } else {
+            elem = _data.front();
+            _data.pop_front();
+        }
+        return elem;
+    }
+#endif
+
+    /// Blocking write
+    void write(const __STREAM_T__& tail) { 
+#ifdef HLS_STREAM_THREAD_SAFE
+        std::unique_lock<std::mutex> ul(_mutex);
+#endif
+        _data.push_back(tail);
+#ifdef HLS_STREAM_THREAD_SAFE
+        _condition_var.notify_one();
+#endif
+    }
+
+    /// Nonblocking read
+    bool read_nb(__STREAM_T__& head) {
+#ifdef HLS_STREAM_THREAD_SAFE
+        std::lock_guard<std::mutex> lg(_mutex);
+#endif    
+        bool is_empty = _data.empty();
+        if (is_empty) {
+            head = __STREAM_T__();
+        } else {
+            __STREAM_T__ elem(_data.front());
+            _data.pop_front();
+            head = elem;
+        }
+        return !is_empty;
+    }
+
+    /// Nonblocking write
+    bool write_nb(const __STREAM_T__& tail) {
+        bool is_full = full();
+        write(tail);
+        return !is_full;
+    }
+
+    /// Fifo size
+    size_t size() {
+        return _data.size();
+    }
+};
+
+} // namespace hls
+
+#endif // __cplusplus
+#endif  // X_HLS_STREAM_SIM_H
+

da4ml/codegen/hls/source/ap_types/utils/x_hls_utils.h

@@ -0,0 +1,80 @@
+#ifndef X_HLS_UTILS_H
+#define X_HLS_UTILS_H
+#include "ap_fixed.h"
+#include <limits>
+
+namespace hls {
+
+    template<typename T>
+    class numeric_limits {
+    public:
+        static T max()     { return std::numeric_limits<T>::max(); }
+        static T min()     { return std::numeric_limits<T>::min(); }
+        static T epsilon() { return std::numeric_limits<T>::epsilon(); }
+    };
+
+    template <int W, int I, ap_q_mode Q, ap_o_mode O>
+    class numeric_limits<ap_fixed<W,I,Q,O> > {
+    public:
+        static ap_fixed<W,I,Q,O> max() {
+            ap_int<W> m = ::hls::numeric_limits<ap_int<W> >::max();
+            ap_fixed<W,I,Q,O> x;
+            x(W-1,0) = m(W-1,0);
+            return x;
+        }
+        static ap_fixed<W,I,Q,O> min() {
+            ap_int<W> m = ::hls::numeric_limits<ap_int<W> >::min();
+            ap_fixed<W,I,Q,O> x;
+            x(W-1,0) = m(W-1,0);
+            return x;
+        }
+        static ap_fixed<W,I,Q,O> epsilon() {
+          ap_fixed<W,I,Q,O> x = 0;
+          x[0] = 1;
+          return x;
+        }
+    };
+
+    template <int W, int I, ap_q_mode Q, ap_o_mode O>
+    class numeric_limits<ap_ufixed<W,I,Q,O> > {
+    public:
+        static ap_ufixed<W,I,Q,O> max() {
+            ap_uint<W> m = ::hls::numeric_limits<ap_uint<W> >::max();
+            ap_ufixed<W,I,Q,O> x;
+            x(W-1,0) = m(W-1,0);
+            return x;
+        }
+        static ap_ufixed<W,I,Q,O> min() { return 0; }
+        static ap_ufixed<W,I,Q,O> epsilon() {
+          ap_ufixed<W,I,Q,O> x = 0;
+          x[0] = 1;
+          return x;
+        }
+    };
+
+    template <int W>
+    class numeric_limits<ap_int<W> > {
+    public:
+        static ap_int<W> max() { ap_int<W> m = min(); return ~m; }
+        static ap_int<W> min() { ap_int<W> m = 0; m[W-1] = 1; return m; }
+        static ap_int<W> epsilon() {
+          ap_int<W> x = 0;
+          x[0] = 1;
+          return x;
+        }
+    };
+
+    template <int W>
+    class numeric_limits<ap_uint<W> > {
+    public:
+        static ap_uint<W> max() { ap_uint<W> zero = 0; return ~zero; }
+        static ap_uint<W> min() { return 0; }
+        static ap_uint<W> epsilon() {
+          ap_uint<W> x = 0;
+          x[0] = 1;
+          return x;
+        }
+    };
+}
+
+#endif

da4ml/codegen/hls/source/binder_util.hh

@@ -0,0 +1,71 @@
+#pragma once
+#include <cstddef>
+
+#ifdef _OPENMP
+#include <algorithm>
+#include <omp.h>
+constexpr bool _openmp = true;
+#else
+constexpr bool _openmp = false;
+#endif
+
+template <typename CONFIG_T, typename T>
+void _inference(T *c_inp, T *c_out, size_t n_samples) {
+    typename CONFIG_T::inp_t in_fixed_buf[CONFIG_T::N_inp];
+    typename CONFIG_T::out_t out_fixed_buf[CONFIG_T::N_out];
+
+    for (size_t i = 0; i < n_samples; ++i) {
+        size_t offset_in = i * CONFIG_T::N_inp;
+        size_t offset_out = i * CONFIG_T::N_out;
+        for (size_t j = 0; j < CONFIG_T::N_inp; ++j) {
+            in_fixed_buf[j] = c_inp[offset_in + j];
+        }
+
+        CONFIG_T::f(in_fixed_buf, out_fixed_buf);
+
+        for (size_t j = 0; j < CONFIG_T::N_out; ++j) {
+            c_out[offset_out + j] = out_fixed_buf[j];
+        }
+    }
+}
+
+template <typename CONFIG_T, typename T>
+void batch_inference(T *c_inp, T *c_out, size_t n_samples, size_t n_threads) {
+    if (n_threads > 1 || n_threads == 0) {
+#ifdef _OPENMP
+        size_t min_samples_per_thread;
+        size_t n_max_threads;
+        if (n_threads == 0) {
+            min_samples_per_thread = 1;
+            n_max_threads = omp_get_max_threads();
+        }
+        else {
+            min_samples_per_thread = std::max<size_t>(1, n_samples / n_threads);
+            n_max_threads = n_threads;
+        }
+        size_t n_sample_per_thread =
+            n_samples / n_max_threads + (n_samples % n_max_threads ? 1 : 0);
+        n_sample_per_thread =
+            std::max<size_t>(n_sample_per_thread, min_samples_per_thread);
+        size_t n_thread = n_samples / n_sample_per_thread;
+        n_thread += (n_samples % n_sample_per_thread) ? 1 : 0;
+
+#pragma omp parallel for num_threads(n_thread) schedule(static)
+        for (size_t i = 0; i < n_thread; ++i) {
+            size_t start = i * n_sample_per_thread;
+            size_t end = std::min<size_t>(start + n_sample_per_thread, n_samples);
+            size_t n_samples_this_thread = end - start;
+            size_t offset_in = start * CONFIG_T::N_inp;
+            size_t offset_out = start * CONFIG_T::N_out;
+            _inference<CONFIG_T, T>(
+                &c_inp[offset_in], &c_out[offset_out], n_samples_this_thread
+            );
+        }
+#else
+        _inference<CONFIG_T, T>(c_inp, c_out, n_samples);
+#endif
+    }
+    else {
+        _inference<CONFIG_T, T>(c_inp, c_out, n_samples);
+    }
+}

da4ml/codegen/hls/source/build_binder.mk

@@ -0,0 +1,22 @@
+default: slow
+INCLUDES = -I ap_types -I .
+CXXFLAGS = -fPIC
+CFLAGS = -std=c++17 -fPIC
+LIBNAME = lib$(PRJ_NAME)_$(STAMP).so
+
+fast: CXXFLAGS += -O3
+fast: $(LIBNAME)
+
+slow: CXXFLAGS += -O
+slow: $(LIBNAME)
+
+$(PRJ_NAME)_$(STAMP).o: $(PRJ_NAME).cc
+	$(CC) -c $(PRJ_NAME).cc -o $(PRJ_NAME)_$(STAMP).o $(INCLUDES) $(CXXFLAGS) $(EXTRA_CXXFLAGS)
+
+$(LIBNAME): $(PRJ_NAME)_$(STAMP).o $(PRJ_NAME)_bridge.cc
+	$(CXX) $(INCLUDES) $(CXXFLAGS) -shared -o $@ $(PRJ_NAME)_$(STAMP).o $(PRJ_NAME)_bridge.cc $(EXTRA_CXXFLAGS)
+
+clean:
+	rm -f $(LIBNAME) $(PRJ_NAME)_$(STAMP).o
+
+.PHONY: clean

da4ml/codegen/hls/source/vitis_bitshift.hh

@@ -0,0 +1,32 @@
+#pragma once
+#include "ap_fixed.h"
+
+template <int s, int b, int i, ap_q_mode Q, ap_o_mode O, int N>
+ap_fixed<b, i + s> bit_shift(ap_fixed<b, i, Q, O, N> x) {
+#pragma HLS INLINE
+    ap_fixed<b, i + s> r;
+    r.range() = x.range();
+    return r;
+};
+
+template <int s, int b, int i, ap_q_mode Q, ap_o_mode O, int N>
+ap_ufixed<b, i + s> bit_shift(ap_ufixed<b, i, Q, O, N> x) {
+#pragma HLS INLINE
+    ap_ufixed<b, i + s> r;
+    r.range() = x.range();
+    return r;
+};
+
+template <int s, int b> ap_fixed<b, s> bit_shift(ap_int<b> x) {
+#pragma HLS INLINE
+    ap_fixed<b, s> r;
+    r.range() = x.range();
+    return r;
+};
+
+template <int s, int b> ap_ufixed<b, s> bit_shift(ap_uint<b> x) {
+#pragma HLS INLINE
+    ap_ufixed<b, s> r;
+    r.range() = x.range();
+    return r;
+};

da4ml/codegen/rtl/__init__.py

@@ -0,0 +1,15 @@
+from .rtl_model import RTLModel, VerilogModel, VHDLModel
+from .verilog import comb_logic_gen as verilog_comb_logic_gen
+from .verilog import generate_io_wrapper as verilog_generate_io_wrapper
+from .vhdl import comb_logic_gen as vhdl_comb_logic_gen
+from .vhdl import generate_io_wrapper as vhdl_generate_io_wrapper
+
+__all__ = [
+    'RTLModel',
+    'VerilogModel',
+    'VHDLModel',
+    'verilog_comb_logic_gen',
+    'verilog_generate_io_wrapper',
+    'vhdl_comb_logic_gen',
+    'vhdl_generate_io_wrapper',
+]

da4ml/codegen/rtl/common_source/binder_util.hh

@@ -0,0 +1,99 @@
+#include "ioutil.hh"
+#include <verilated.h>
+
+#ifdef _OPENMP
+#include <omp.h>
+constexpr bool _openmp = true;
+#else
+constexpr bool _openmp = false;
+#endif
+
+template <typename CONFIG_T>
+std::enable_if_t<CONFIG_T::II != 0>
+_inference(int32_t *c_inp, int32_t *c_out, size_t n_samples) {
+    auto dut = std::make_unique<typename CONFIG_T::dut_t>();
+
+    size_t clk_req = n_samples * CONFIG_T::II + (CONFIG_T::latency - CONFIG_T::II) + 1;
+
+    for (size_t t_inp = 0; t_inp < clk_req; ++t_inp) {
+        size_t t_out = t_inp - CONFIG_T::latency;
+
+        if (t_inp < n_samples * CONFIG_T::II && t_inp % CONFIG_T::II == 0) {
+            write_input<CONFIG_T::N_inp, CONFIG_T::max_inp_bw>(
+                dut->model_inp, &c_inp[t_inp / CONFIG_T::II * CONFIG_T::N_inp]
+            );
+        }
+
+        dut->clk = 0;
+        dut->eval();
+        dut->clk = 1;
+        dut->eval();
+
+        if (t_inp >= CONFIG_T::latency && t_out % CONFIG_T::II == 0) {
+            read_output<CONFIG_T::N_out, CONFIG_T::max_out_bw>(
+                dut->model_out, &c_out[t_out / CONFIG_T::II * CONFIG_T::N_out]
+            );
+        }
+    }
+
+    dut->final();
+}
+
+template <typename CONFIG_T>
+std::enable_if_t<CONFIG_T::II == 0>
+_inference(int32_t *c_inp, int32_t *c_out, size_t n_samples) {
+    auto dut = std::make_unique<typename CONFIG_T::dut_t>();
+
+    for (size_t i = 0; i < n_samples; ++i) {
+        write_input<CONFIG_T::N_inp, CONFIG_T::max_inp_bw>(
+            dut->model_inp, &c_inp[i * CONFIG_T::N_inp]
+        );
+        dut->eval();
+        read_output<CONFIG_T::N_out, CONFIG_T::max_out_bw>(
+            dut->model_out, &c_out[i * CONFIG_T::N_out]
+        );
+    }
+
+    dut->final();
+}
+
+template <typename CONFIG_T>
+void batch_inference(int32_t *c_inp, int32_t *c_out, size_t n_samples, size_t n_threads) {
+    if (n_threads > 1 || n_threads == 0) {
+#ifdef _OPENMP
+        size_t min_samples_per_thread;
+        size_t n_max_threads;
+        if (n_threads == 0) {
+            min_samples_per_thread = 1;
+            n_max_threads = omp_get_max_threads();
+        }
+        else {
+            min_samples_per_thread = std::max<size_t>(1, n_samples / n_threads);
+            n_max_threads = n_threads;
+        }
+        size_t n_sample_per_thread =
+            n_samples / n_max_threads + (n_samples % n_max_threads ? 1 : 0);
+        n_sample_per_thread =
+            std::max<size_t>(n_sample_per_thread, min_samples_per_thread);
+        size_t n_thread = n_samples / n_sample_per_thread;
+        n_thread += (n_samples % n_sample_per_thread) ? 1 : 0;
+
+#pragma omp parallel for num_threads(n_thread) schedule(static)
+        for (size_t i = 0; i < n_thread; ++i) {
+            size_t start = i * n_sample_per_thread;
+            size_t end = std::min<size_t>(start + n_sample_per_thread, n_samples);
+            size_t n_samples_this_thread = end - start;
+            size_t offset_in = start * CONFIG_T::N_inp;
+            size_t offset_out = start * CONFIG_T::N_out;
+            _inference<CONFIG_T>(
+                &c_inp[offset_in], &c_out[offset_out], n_samples_this_thread
+            );
+        }
+#else
+        _inference<CONFIG_T>(c_inp, c_out, n_samples);
+#endif
+    }
+    else {
+        _inference<CONFIG_T>(c_inp, c_out, n_samples);
+    }
+}

da4ml/codegen/rtl/common_source/build_binder.mk

@@ -0,0 +1,34 @@
+default: slow
+
+VERILATOR_ROOT = $(shell verilator -V | grep -a VERILATOR_ROOT | tail -1 | awk '{{print $$3}}')
+INCLUDES = -I./obj_dir -I$(VERILATOR_ROOT)/include -I../src
+WARNINGS = -Wl,--no-undefined
+CFLAGS = -std=c++17 -fPIC
+LINKFLAGS = $(INCLUDES) $(WARNINGS)
+LIBNAME = lib$(VM_PREFIX)_$(STAMP).so
+N_JOBS ?= $(shell nproc)
+VERILATOR_FLAGS ?=
+
+../src/$(VM_PREFIX).v: $(wildcard ../src/$(VM_PREFIX).vhd) $(wildcard ../src/$(VM_PREFIX)_stage*.vhd)
+# vhdl specific - convert to verilog first for verilating
+	mkdir -p obj_dir
+	cp ../src/memfiles/* ./ 2>/dev/null || true
+	ghdl -a --std=08 --workdir=obj_dir ../src/static/multiplier.vhd ../src/static/mux.vhd ../src/static/negative.vhd ../src/static/shift_adder.vhd ../src/static/lookup_table.vhd $(wildcard ../src/$(VM_PREFIX:_wrapper=)_stage*.vhd) $(wildcard ../src/$(VM_PREFIX:_wrapper=).vhd) ../src/$(VM_PREFIX).vhd
+	ghdl synth --std=08 --workdir=obj_dir --out=verilog $(VM_PREFIX) > $(VM_PREFIX).v
+
+./obj_dir/libV$(VM_PREFIX).a ./obj_dir/libverilated.a ./obj_dir/V$(VM_PREFIX)__ALL.a: ../src/$(VM_PREFIX).v $(wildcard ../src/$(VM_PREFIX)_stage*.v)
+	verilator --cc -j $(N_JOBS) -build $(VM_PREFIX).v --prefix V$(VM_PREFIX) $(VERILATOR_FLAGS) -CFLAGS "$(CFLAGS)" -I../src -I../src/static
+
+$(LIBNAME): ./obj_dir/libV$(VM_PREFIX).a ./obj_dir/libverilated.a ./obj_dir/V$(VM_PREFIX)__ALL.a $(VM_PREFIX)_binder.cc
+	$(CXX) $(CFLAGS) $(LINKFLAGS) $(CXXFLAGS2) -pthread -shared -o $(LIBNAME) $(VM_PREFIX)_binder.cc ./obj_dir/libV$(VM_PREFIX).a ./obj_dir/libverilated.a ./obj_dir/V$(VM_PREFIX)__ALL.a $(EXTRA_CXXFLAGS)
+
+
+fast: CFLAGS += -O3
+fast: $(LIBNAME)
+
+slow: CFLAGS += -O
+slow: $(LIBNAME)
+
+clean:
+	rm -rf obj_dir
+	rm -f $(LIBNAME)