data.h

/* Copyright 2013-present Barefoot Networks, Inc.
 *
 * 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.
 */
 
/*
 * Antonin Bas (antonin@barefootnetworks.com)
 *
 */
 
 
#ifndef BM_BM_SIM_DATA_H_
#define BM_BM_SIM_DATA_H_
 
#include <iosfwd>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
#include <cstring>
#include <cassert>
 
#include "bignum.h"
#include "bytecontainer.h"
 
namespace bm {
 
using bignum::Bignum;
 
class Data {
 public:
  Data() {}
 
  template<typename T,
           typename std::enable_if<std::is_integral<T>::value, int>::type = 0>
  explicit Data(T i)
    : value(i) {}
 
  Data(const char *bytes, int nbytes) {
    bignum::import_bytes(&value, bytes, nbytes);
  }
 
  virtual ~Data() { }
 
  static char char2digit(char c) {
    if (c >= '0' && c <= '9')
      return (c - '0');
    if (c >= 'A' && c <= 'F')
      return (c - 'A' + 10);
    if (c >= 'a' && c <= 'f')
      return (c - 'a' + 10);
    assert(0);
    return 0;
  }
 
  explicit Data(const std::string &hexstring) {
    set(hexstring);
  }
 
  virtual void export_bytes() {}
 
  int sign() const { return value.sign(); }
 
  // TODO(Antonin): need to figure out what to do with signed values
  template<typename T,
           typename std::enable_if<std::is_integral<T>::value, int>::type = 0>
  void set(T i) {
    value = i;
    export_bytes();
  }
 
  template<typename T,
           typename std::enable_if<std::is_enum<T>::value, int>::type = 0>
  void set(T i) {
    value = static_cast<int>(i);
    export_bytes();
  }
 
  void set(const char *bytes, int nbytes) {
    bignum::import_bytes(&value, bytes, nbytes);
    export_bytes();
  }
 
  void set(const Data &data) {
    value = data.value;
    export_bytes();
  }
 
  void set(Data &&data) {
    value = std::move(data.value);
    export_bytes();
  }
 
  void set(const ByteContainer &bc) {
    bignum::import_bytes(&value, bc.data(), bc.size());
    export_bytes();
  }
 
  void
#if __GNUC__ == 5 && __GNUC_MINOR__ <= 2
  // With g++-5.2, and when compiling with -O2, I sometimes get a segfault in
  // this function (after calling mpz_import). I do not see anything wrong with
  // this code and g++-4.8/9, as well as g++5.3, do not have this issue. I was
  // not able to reproduce this bug with a simpler code sample (one without the
  // bignum) and the assembly is too difficult for me to look at, so I am just
  // going to blame it on the compiler and move on...
  __attribute__((optimize("O0")))
#endif
  set(const std::string &hexstring) {
    std::vector<char> bytes;
    size_t idx = 0;
    bool neg = false;
 
    if (hexstring[idx] == '-') {
      neg = true;
      ++idx;
    }
    if (hexstring[idx] == '0' && hexstring[idx + 1] == 'x') {
      idx += 2;
    }
    size_t size = hexstring.size();
    assert((size - idx) > 0);
 
    if ((size - idx) % 2 != 0) {
      char c = char2digit(hexstring[idx++]);
      bytes.push_back(c);
    }
 
    for (; idx < size; ) {
      char c = char2digit(hexstring[idx++]) << 4;
      c += char2digit(hexstring[idx++]);
      bytes.push_back(c);
    }
 
    bignum::import_bytes(&value, bytes.data(), bytes.size());
    if (neg) value = -value;
    export_bytes();  // not very efficient for fields, we import then export...
  }
 
  template<typename T,
           typename std::enable_if<std::is_integral<T>::value, int>::type = 0>
  T get() const {
    assert(arith);
    return value.convert_to<typename std::remove_const<T>::type>();
  }
 
  unsigned int get_uint() const {
    assert(arith);
    return value.convert_to<unsigned int>();
  }
 
  uint64_t get_uint64() const {
    assert(arith);
    return value.convert_to<uint64_t>();
  }
 
  int get_int() const {
    assert(arith);
    return value.convert_to<int>();
  }
 
  std::string get_string() const {
    assert(arith);
    const size_t export_size = bignum::export_size_in_bytes(value);
    std::string s(export_size, '\x00');
    // this is not technically correct, but works for all compilers
    bignum::export_bytes(&s[0], export_size, value);
    return s;
  }
 
  std::string get_string_repr() const {
    assert(arith);
    return value.convert_to<std::string>();
  }
 
  bool get_arith() const { return arith; }
 
  // TODO(antonin): overload operators for those ?
 
  void add(const Data &src1, const Data &src2) {
    assert(src1.arith && src2.arith);
    value = src1.value + src2.value;
    export_bytes();
  }
 
  void sub(const Data &src1, const Data &src2) {
    assert(src1.arith && src2.arith);
    value = src1.value - src2.value;
    export_bytes();
  }
 
  void mod(const Data &src1, const Data &src2) {
    assert(src1.arith && src2.arith);
    assert(src1.value >= 0 && src2.value > 0);
    value = src1.value % src2.value;
    export_bytes();
  }
 
  void divide(const Data &src1, const Data &src2) {
    assert(src1.arith && src2.arith);
    assert(src1.value >= 0 && src2.value > 0);
    value = src1.value / src2.value;
    export_bytes();
  }
 
  void multiply(const Data &src1, const Data &src2) {
    assert(src1.arith && src2.arith);
    value = src1.value * src2.value;
    export_bytes();
  }
 
  void shift_left(const Data &src1, const Data &src2) {
    assert(src1.arith && src2.arith);
    assert(src2.value >= 0);
    value = src1.value << (src2.get_uint());
    export_bytes();
  }
 
  void shift_right(const Data &src1, const Data &src2) {
    assert(src1.arith && src2.arith);
    assert(src2.value >= 0);
    value = src1.value >> (src2.get_uint());
    export_bytes();
  }
 
  void shift_left(const Data &src1, unsigned int src2) {
    assert(src1.arith);
    value = src1.value << src2;
    export_bytes();
  }
 
  void shift_right(const Data &src1, unsigned int src2) {
    assert(src1.arith);
    value = src1.value >> src2;
    export_bytes();
  }
 
  void bit_and(const Data &src1, const Data &src2) {
    assert(src1.arith && src2.arith);
    value = src1.value & src2.value;
    export_bytes();
  }
 
  void bit_or(const Data &src1, const Data &src2) {
    assert(src1.arith && src2.arith);
    value = src1.value | src2.value;
    export_bytes();
  }
 
  void bit_xor(const Data &src1, const Data &src2) {
    assert(src1.arith && src2.arith);
    value = src1.value ^ src2.value;
    export_bytes();
  }
 
  void bit_neg(const Data &src) {
    assert(src.arith);
    value = ~src.value;
    export_bytes();
  }
 
  void two_comp_mod(const Data &src, const Data &width) {
    static const Bignum one(1);
    unsigned int uwidth = width.get_uint();
    Bignum mask = (one << uwidth) - 1;
    Bignum max = (one << (uwidth - 1)) - 1;
    Bignum min = -(one << (uwidth - 1));
    if (src.value < min || src.value > max) {
      value = src.value & mask;
      if (value > max)
        value -= (one << uwidth);
    } else {
      value = src.value;
    }
    export_bytes();
  }
 
  void usat_cast(const Data &src, const Data &width) {
    static const Bignum one(1);
    unsigned int uwidth = width.get_uint();
    Bignum max = (one << uwidth) - 1;
    if (src.value > max)
      value = max;
    else if (src.value < 0)
      value = 0;
    else
      value = src.value;
    export_bytes();
  }
 
  void sat_cast(const Data &src, const Data &width) {
    static const Bignum one(1);
    unsigned int uwidth = width.get_uint();
    Bignum max = (one << (uwidth - 1)) - 1;
    Bignum min = -(one << (uwidth - 1));
    if (src.value > max)
      value = max;
    else if (src.value < min)
      value = min;
    else
      value = src.value;
    export_bytes();
  }
 
  template<typename T,
           typename std::enable_if<std::is_integral<T>::value, int>::type = 0>
  bool test_eq(T i) const {
    return (value == i);
  }
 
  friend bool operator==(const Data &lhs, const Data &rhs) {
    assert(lhs.arith && rhs.arith);
    return lhs.value == rhs.value;
  }
 
  friend bool operator!=(const Data &lhs, const Data &rhs) {
    assert(lhs.arith && rhs.arith);
    return !(lhs == rhs);
  }
 
  friend bool operator>(const Data &lhs, const Data &rhs) {
    assert(lhs.arith && rhs.arith);
    return lhs.value > rhs.value;
  }
 
  friend bool operator>=(const Data &lhs, const Data &rhs) {
    assert(lhs.arith && rhs.arith);
    return lhs.value >= rhs.value;
  }
 
  friend bool operator<(const Data &lhs, const Data &rhs) {
    assert(lhs.arith && rhs.arith);
    return lhs.value < rhs.value;
  }
 
  friend bool operator<=(const Data &lhs, const Data &rhs) {
    assert(lhs.arith && rhs.arith);
    return lhs.value <= rhs.value;
  }
 
  friend std::ostream& operator<<(std::ostream &out, const Data &d) {
    assert(d.arith);
    out << d.value;
    return out;
  }
 
  // Copy constructor
  Data(const Data &other)
    : arith(other.arith) {
    if (other.arith) value = other.value;
  }
 
  // Copy assignment operator
  Data &operator=(const Data &other) {
    Data tmp(other);  // re-use copy-constructor
    *this = std::move(tmp);  // re-use move-assignment
    return *this;
  }
 
  Data(Data &&other) = default;
 
  Data &operator=(Data &&other) = default;
 
 protected:
  Bignum value{0};
  bool arith{true};
};
 
}  // namespace bm
 
#endif  // BM_BM_SIM_DATA_H_