function.h

// Copyright (c) 2021-2023, David H. Hovemeyer <david.hovemeyer@gmail.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
 
#ifndef FUNCTION_H
#define FUNCTION_H
 
#include <string>
#include <cassert>
#include <map>
#include "node.h"
#include "symtab.h"
#include "instruction_seq.h"
#ifdef SOLUTION
#include "lowlevel.h"
#endif
 
class Function {
#ifdef SOLUTION
public:
  typedef std::map<int, MachineReg> GlobalRegMap;
 
#endif
private:
  std::string m_name;
  Node *m_funcdef_ast; // function definition AST node
  Symbol *m_symbol; // function symbol table entry
  std::shared_ptr<InstructionSequence> m_hl_iseq; // high-level code
  std::shared_ptr<InstructionSequence> m_ll_iseq; // low-level code
#ifdef SOLUTION
  unsigned m_total_local_storage;
  int m_first_temp_vreg;
  int m_num_vregs_used;
  std::map<int, unsigned> m_vreg_storage_offsets;
  int m_num_spill_locs;
  GlobalRegMap m_global_regs;
#endif
 
public:
  Function(const std::string &name, Node *funcdef_ast, Symbol *symbol);
  ~Function();
 
  std::string get_name() const;
 
  Node *get_funcdef_ast() const;
 
  Symbol *get_symbol() const;
 
  std::shared_ptr<InstructionSequence> get_hl_iseq() const;
 
  void set_hl_iseq(const std::shared_ptr<InstructionSequence> &hl_iseq);
 
  std::shared_ptr<InstructionSequence> get_ll_iseq() const;
 
  void set_ll_iseq(const std::shared_ptr<InstructionSequence> &ll_iseq);
 
#ifdef SOLUTION
  void set_total_local_storage(unsigned total_local_storage) { m_total_local_storage = total_local_storage; }
  unsigned get_total_local_storage() const { return m_total_local_storage; }
 
  void set_first_temp_vreg(int first_temp_vreg) { m_first_temp_vreg = first_temp_vreg; }
  int get_first_temp_vreg() const { return m_first_temp_vreg; }
 
  void set_num_vregs_used(int num_vregs_used) { m_num_vregs_used = num_vregs_used; }
  int get_num_vregs_used() const { return m_num_vregs_used; }
 
  void assign_vreg_storage(int vreg, unsigned offset) {
    assert(!vreg_reqires_storage(vreg));
    m_vreg_storage_offsets[vreg] = offset;
  }
 
  bool vreg_reqires_storage(int vreg) const {
    return m_vreg_storage_offsets.count(vreg) > 0;
  }
 
  unsigned get_vreg_storage_offset(int vreg) const {
    auto i = m_vreg_storage_offsets.find(vreg);
    assert(i != m_vreg_storage_offsets.end());
    return i->second;
  }
 
  void set_num_spill_locs(int num_spill_locs) { m_num_spill_locs = num_spill_locs; }
  int get_num_spill_locs() const { return m_num_spill_locs; }
 
  void allocate_global_reg(int vreg, MachineReg mreg) {
    assert(!has_global_reg(vreg));
    m_global_regs[vreg] = mreg;
  }
 
  bool has_global_reg(int vreg) const { return m_global_regs.count(vreg) > 0; }
 
  MachineReg get_global_reg(int vreg) const {
    auto i = m_global_regs.find(vreg);
    assert(i != m_global_regs.end());
    return i->second;
  }
 
  // Iterators over vreg to global mreg assignments
  GlobalRegMap::const_iterator greg_begin() const { return m_global_regs.cbegin(); }
  GlobalRegMap::const_iterator greg_end() const { return m_global_regs.cend(); }
 
  // Reverse iterators over vreg to global mreg assignments
  GlobalRegMap::const_reverse_iterator greg_rbegin() const { return m_global_regs.crbegin(); }
  GlobalRegMap::const_reverse_iterator greg_rend() const { return m_global_regs.crend(); }
 
  unsigned get_num_global_regs_assigned() const { return unsigned(m_global_regs.size()); }
#endif
};
 
#endif // FUNCTION_H