misc.h

 
#ifndef BACKENDS_TOFINO_BF_ASM_MISC_H_
#define BACKENDS_TOFINO_BF_ASM_MISC_H_
 
#include <memory>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>
 
#include "asm-types.h"
#include "backends/tofino/bf-asm/json.h"
 
template <class T>
auto setup_muxctl(T &reg, int val) -> decltype((void)reg.enabled_2bit_muxctl_enable) {
    reg.enabled_2bit_muxctl_select = val;
    reg.enabled_2bit_muxctl_enable = 1;
}
template <class T>
auto setup_muxctl(T &reg, int val) -> decltype((void)reg.enabled_3bit_muxctl_enable) {
    reg.enabled_3bit_muxctl_select = val;
    reg.enabled_3bit_muxctl_enable = 1;
}
template <class T>
auto setup_muxctl(T &reg, int val) -> decltype((void)reg.enabled_4bit_muxctl_enable) {
    reg.enabled_4bit_muxctl_select = val;
    reg.enabled_4bit_muxctl_enable = 1;
}
template <class T>
auto setup_muxctl(T &reg, int val) -> decltype((void)reg.enabled_5bit_muxctl_enable) {
    reg.enabled_5bit_muxctl_select = val;
    reg.enabled_5bit_muxctl_enable = 1;
}
template <class T>
auto setup_muxctl(T &reg, int val) -> decltype((void)reg.exactmatch_row_vh_xbar_enable) {
    reg.exactmatch_row_vh_xbar_select = val;
    reg.exactmatch_row_vh_xbar_enable = 1;
}
 
template <class T, class Alloc>
void append(std::vector<T, Alloc> &a, const std::vector<T, Alloc> &b) {
    for (auto &e : b) a.push_back(e);
}
 
template <class T, class U>
T join(const std::vector<T> &vec, U sep) {
    T rv;
    bool first = true;
    for (auto &el : vec) {
        if (first)
            first = false;
        else
            rv += sep;
        rv += el;
    }
    return rv;
}
 
extern int remove_name_tail_range(std::string &, int *size = nullptr);
 
// Convert an integer to hex string of specified width (in bytes)
std::string int_to_hex_string(unsigned val, unsigned width);
 
// Add a reg to CJSON Configuration Cache
void add_cfg_reg(json::vector &cfg_cache, std::string full_name, std::string name, std::string val);
 
bool check_zero_string(const std::string &s);
 
// Get filename
std::string get_filename(const char *s);
std::string get_directory(const char *s);

void gen_instfield_name(const std::string &fullname, std::string &instname, std::string &fieldname);

template <class T>
struct ptrless {
    bool operator()(const T *a, const T *b) const { return b ? a ? *a < *b : true : false; }
    bool operator()(const std::unique_ptr<T> &a, const std::unique_ptr<T> &b) const {
        return b ? a ? *a < *b : true : false;
    }
};
 
/* word with size (lowest) bits set */
uint64_t bitMask(unsigned size);
/* word with range of bits from lo to hi (inclusive) set */
uint64_t bitRange(unsigned lo, unsigned hi);
 
int parity(uint32_t v);
int parity_2b(uint32_t v);  // two-bit parity (parity of pairs in the word)
 
inline bool check_value(const value_t value, const decltype(value_t::i) expected) {
    if (!CHECKTYPE(value, tINT)) return false;
    if (value.i != expected) {
        error(value.lineno, "unexpected value %ld; expected %ld", value.i, expected);
        return false;
    }
    return true;
}

template <typename IntType,
          typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
bool check_range_strict(value_t value, IntType lo, IntType hi) {
    auto format_error_message([](value_t value, IntType lo, IntType hi) {
        /* -- As we don't know actual type of the IntType, we cannot use the printf-like
         *    formatting. */
        std::ostringstream oss;
        oss << "value " << value.i << " is out of allowed range <" << +lo << "; " << +hi << ">";
        error(value.lineno, "%s", oss.str().c_str());
    });
 
    if (!CHECKTYPE(value, tINT)) return false;
 
    /* -- Handle different ranges (signed, unsigned, different size) of the value_t::i
     *    and IntType. */
 
    if (!std::in_range<IntType>(value.i)) {
        format_error_message(value, lo, hi);
        return false;
    }
 
    /* -- Now check requested limits */
    IntType converted(static_cast<IntType>(value.i));
    if (converted < lo || converted > hi) {
        format_error_message(value, lo, hi);
        return false;
    }
    return true;
}
 
inline bool check_range(const value_t value, const decltype(value_t::i) lo,
                        const decltype(value_t::i) hi) {
    return check_range_strict<decltype(value_t::i)>(value, lo, hi);
}
 
inline bool check_range_match(const value_t &match, const decltype(match_t::word0) mask,
                              int width) {
    if (!CHECKTYPE(match, tMATCH)) return false;
    if ((match.m.word0 | match.m.word1) != mask) {
        error(match.lineno, "invalid match width; expected %i bits", width);
        return false;
    }
    return true;
}
 
template <typename IntType>
void convert_i2m(IntType i, match_t &m) {
    static_assert(sizeof(IntType) == sizeof(match_t::word0));
    static_assert(std::is_integral<IntType>::value);
 
    m.word0 = ~static_cast<decltype(match_t::word0)>(i);
    m.word1 = static_cast<decltype(match_t::word0)>(i);
}
 
bool check_bigint_unsigned(value_t value, uint32_t byte_width);

inline void fix_match_star(match_t &match, const decltype(match_t::word0) mask) {
    if (match.word0 == 0 && match.word1 == 0) match.word0 = match.word1 = mask;
}

bool input_int_match(const value_t value, match_t &match, int width);

bool require_keys(const value_t &data, std::set<const char *> keys);
 
#endif /* BACKENDS_TOFINO_BF_ASM_MISC_H_ */