instruction_seq.h

Go to the documentation of this file.

// 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 INSTRUCTION_SEQ_H
#define INSTRUCTION_SEQ_H
 
#include <vector>
#include <string>
#include <map>
#include "instruction_seq_iter.h"
 
 
class Instruction;
 
enum BasicBlockKind {
  BASICBLOCK_ENTRY,     
  BASICBLOCK_EXIT,      
  BASICBLOCK_INTERIOR,  
};
 
class InstructionSequence {
private:
  struct Slot {
    std::string label;
    Instruction *ins;
  };
 
  std::vector<Slot> m_instructions;
  std::map<std::string, unsigned> m_label_map; // label to instruction index map
  std::string m_next_label;
 
  // These fields are only used when the InstructionSequence
  // is used as a basic block in a ControlFlowGraph
  BasicBlockKind m_kind;
  unsigned m_block_id;
  int m_code_order;
 
  // copy constructor and assignment operator are not allowed
  InstructionSequence(const InstructionSequence &);
  InstructionSequence &operator=(const InstructionSequence &);
 
public:
  // Iterator types, providing a pointer to an Instruction object when
  // dereferenced. These are random access.
 
  typedef ISeqIterator<std::vector<Slot>::const_iterator> const_iterator;
 
  typedef ISeqIterator<std::vector<Slot>::const_reverse_iterator> const_reverse_iterator;
 
  InstructionSequence();
 
  InstructionSequence(BasicBlockKind kind, int code_order, const std::string &block_label);
 
  virtual ~InstructionSequence();
 
  InstructionSequence *duplicate() const;
 
  // get begin and end const_iterators
 
  const_iterator cbegin() const { return const_iterator(m_instructions.cbegin()); }
 
  const_iterator cend() const { return const_iterator(m_instructions.cend()); }
 
  // get begin and end const_reverse_iterators
 
  const_reverse_iterator crbegin() const { return const_reverse_iterator(m_instructions.crbegin()); }
 
  const_reverse_iterator crend() const { return const_reverse_iterator(m_instructions.crend()); }
 
  // Apply a function to each Instruction in order.
  template<typename Fn>
  void apply_to_all(Fn f) {
    for (auto i = cbegin(); i != cend(); ++i)
      f(*i);
  }
 
  void append(Instruction *ins);
 
  unsigned get_length() const;
 
  Instruction *get_instruction(unsigned index) const;
 
  Instruction *get_last_instruction() const;
 
  void define_label(const std::string &label);
 
  bool has_label(unsigned index) const { return !m_instructions.at(index).label.empty(); }
 
  std::string get_label_at_index(unsigned index) const { return m_instructions.at(index).label; }
 
  bool has_label(const_iterator iter) const { return iter.has_label(); }
 
  bool has_label_at_end() const;
 
  const_iterator get_iterator_at_labeled_position(const std::string &label) const;
 
  Instruction *find_labeled_instruction(const std::string &label) const;
 
  unsigned get_index_of_labeled_instruction(const std::string &label) const;
 
  // Member functions used for basic blocks
 
  BasicBlockKind get_kind() const { return m_kind; }
 
  void set_kind(BasicBlockKind kind) { m_kind = kind; }
 
  bool has_block_label() const;
 
  std::string get_block_label() const;
 
  void set_block_label(const std::string &block_label);
 
  unsigned get_block_id() const { return m_block_id; }
 
  void set_block_id(unsigned block_id) { m_block_id = block_id; }
 
  int get_code_order() const { return m_code_order; }
 
  void set_code_order(int code_order) { m_code_order = code_order; }
};
 
#endif // INSTRUCTION_SEQ_H