expressions.h

/* Copyright 2013-2019 Barefoot Networks, Inc.
 * Copyright 2019 VMware, 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
 *
 */

#ifndef BM_BM_SIM_EXPRESSIONS_H_
#define BM_BM_SIM_EXPRESSIONS_H_

#include <unordered_map>
#include <string>
#include <vector>

#include "data.h"
#include "headers.h"
#include "header_unions.h"
#include "phv_forward.h"
#include "stacks.h"

namespace bm {

class RegisterArray;
class RegisterSync;

struct ExpressionTemps;

enum class ExprOpcode {
  LOAD_FIELD, LOAD_HEADER, LOAD_HEADER_STACK, LOAD_LAST_HEADER_STACK_FIELD,
  LOAD_UNION, LOAD_UNION_STACK, LOAD_BOOL, LOAD_CONST, LOAD_LOCAL,
  LOAD_REGISTER_REF, LOAD_REGISTER_GEN,
  ADD, SUB, MOD, DIV, MUL, SHIFT_LEFT, SHIFT_RIGHT,
  EQ_DATA, NEQ_DATA, GT_DATA, LT_DATA, GET_DATA, LET_DATA,
  EQ_HEADER, NEQ_HEADER,
  EQ_UNION, NEQ_UNION,
  EQ_BOOL, NEQ_BOOL,
  AND, OR, NOT,
  BIT_AND, BIT_OR, BIT_XOR, BIT_NEG,
  VALID_HEADER, VALID_UNION,
  TERNARY_OP, SKIP,
  TWO_COMP_MOD,
  USAT_CAST, SAT_CAST,
  DATA_TO_BOOL, BOOL_TO_DATA,
  DEREFERENCE_HEADER_STACK,
  DEREFERENCE_UNION_STACK,
  LAST_STACK_INDEX, SIZE_STACK,
  ACCESS_FIELD,
  ACCESS_UNION_HEADER,
};

enum class ExprType {
  UNKNOWN, DATA, HEADER, HEADER_STACK, BOOL, UNION, UNION_STACK
};

class ExprOpcodesMap {
 public:
  static ExprOpcode get_opcode(std::string expr_name);

 private:
  static ExprOpcodesMap *get_instance();

  ExprOpcodesMap();

 private:
  std::unordered_map<std::string, ExprOpcode> opcodes_map{};
};

class ExprOpcodesUtils {
 public:
  static ExprOpcode get_eq_opcode(ExprType expr_type);
  static ExprOpcode get_neq_opcode(ExprType expr_type);

  static ExprType get_opcode_type(ExprOpcode opcode);
};

struct Op {
  ExprOpcode opcode;

  union {
    int data_dest_index;

    struct {
      header_id_t header;
      int field_offset;
    } field;

    header_id_t header;

    header_stack_id_t header_stack;

    struct {
      header_stack_id_t header_stack;
      int field_offset;
    } stack_field;

    header_union_id_t header_union;

    header_union_stack_id_t header_union_stack;

    bool bool_value;

    int const_offset;

    int local_offset;

    int field_offset;

    int header_offset;

    // In theory, if registers cannot be resized, I could directly store a
    // pointer to the correct register cell, i.e. &(*array)[idx]. However, this
    // gives me more flexibility in case I want to be able to resize the
    // registers arbitrarily in the future.
    struct {
      RegisterArray *array;
      unsigned int idx;
    } register_ref;

    RegisterArray *register_array;

    int skip_num;
  };
};

class Expression {
 public:
  Expression();

  virtual ~Expression() { }

  void push_back_load_field(header_id_t header, int field_offset);
  void push_back_load_bool(bool value);
  void push_back_load_header(header_id_t header);
  void push_back_load_header_stack(header_stack_id_t header_stack);
  void push_back_load_last_header_stack_field(header_stack_id_t header_stack,
                                              int field_offset);
  void push_back_load_header_union(header_union_id_t header_union);
  void push_back_load_header_union_stack(
      header_union_stack_id_t header_union_stack);
  void push_back_load_const(const Data &data);
  void push_back_load_local(const int offset);
  void push_back_load_register_ref(RegisterArray *register_array,
                                   unsigned int idx);
  void push_back_load_register_gen(RegisterArray *register_array);
  void push_back_op(ExprOpcode opcode);
  void push_back_ternary_op(const Expression &e1, const Expression &e2);
  void push_back_access_field(int field_offset);
  void push_back_access_union_header(int header_offset);

  void build();

  void grab_register_accesses(RegisterSync *register_sync) const;

  bool eval_bool(const PHV &phv, const std::vector<Data> &locals = {}) const;
  Data eval_arith(const PHV &phv, const std::vector<Data> &locals = {}) const;
  void eval_arith(const PHV &phv, Data *data,
                  const std::vector<Data> &locals = {}) const;
  Data &eval_arith_lvalue(PHV *phv, const std::vector<Data> &locals = {}) const;
  Header &eval_header(PHV *phv, const std::vector<Data> &locals = {}) const;
  HeaderStack &eval_header_stack(
      PHV *phv, const std::vector<Data> &locals = {}) const;
  HeaderUnion &eval_header_union(
      PHV *phv, const std::vector<Data> &locals = {}) const;
  HeaderUnionStack &eval_header_union_stack(
      PHV *phv, const std::vector<Data> &locals = {}) const;

  bool empty() const;

  // I am authorizing copy for this object
  Expression(const Expression &other) = default;
  Expression &operator=(const Expression &other) = default;

  Expression(Expression &&other) /*noexcept*/ = default;
  Expression &operator=(Expression &&other) /*noexcept*/ = default;

 private:
  int assign_dest_registers();
  void eval_(const PHV &phv,
             const std::vector<Data> &locals,
             ExpressionTemps *temps) const;
  size_t get_num_ops() const;
  void append_expression(const Expression &e);

 private:
  std::vector<Op> ops{};
  std::vector<Data> const_values{};
  int data_registers_cnt{0};
  bool built{false};

  friend class VLHeaderExpression;
};


class ArithExpression : public Expression {
 public:
  void eval(const PHV &phv, Data *data,
            const std::vector<Data> &locals = {}) const {
    eval_arith(phv, data, locals);
  }

  Data &eval_lvalue(PHV *phv, const std::vector<Data> &locals = {}) const {
    return eval_arith_lvalue(phv, locals);
  }
};


class BoolExpression : public Expression {
 public:
  bool eval(const PHV &phv, const std::vector<Data> &locals = {}) const {
    return eval_bool(phv, locals);
  }
};


class VLHeaderExpression {
 public:
  explicit VLHeaderExpression(const ArithExpression &expr);

  ArithExpression resolve(header_id_t header_id);

  const std::vector<int> &get_input_offsets() const;

 private:
  ArithExpression expr;
  std::vector<int> offsets{};
};

}  // namespace bm

#endif  // BM_BM_SIM_EXPRESSIONS_H_