IRBuilder.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
 *
 * 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.
 */
 
#ifndef __IR_BUILDER_H__
#define __IR_BUILDER_H__
 
#include "coco/IR/Module.h"
 
#include <deque>
 
using namespace nncc::core::ADT;
 
class OpBuilder
{
public:
  OpBuilder(coco::Module *module) : _module{module}
  {
    // module SHOULD BE valid
    assert(_module != nullptr);
  }
 
public:
  bool empty(void) const { return _stack.empty(); }
 
  coco::Op *top(void) const
  {
    assert(_stack.size() > 0);
    return _stack.front();
  }
 
  OpBuilder &push(coco::Op *op)
  {
    _stack.push_front(op);
    return (*this);
  }
 
  OpBuilder &load(coco::Object *obj)
  {
    auto op = _module->entity()->op()->create<coco::Load>();
    op->object(obj);
    push(op);
    return (*this);
  }
 
  OpBuilder &add(void) { return binary<coco::Add>(); }
 
  OpBuilder &mul(void) { return binary<coco::Mul>(); }
 
  coco::Op *pop(void)
  {
    assert(_stack.size() > 0);
    auto op = _stack.front();
    _stack.pop_front();
    return op;
  }
 
private:
  template <typename ConcreteOp> OpBuilder &binary()
  {
    assert(_stack.size() >= 2);
    auto left = pop();
    auto right = pop();
 
    auto op = _module->entity()->op()->create<ConcreteOp>();
    op->left(left);
    op->right(right);
    push(op);
 
    return (*this);
  }
 
private:
  coco::Module *_module;
  std::deque<coco::Op *> _stack;
};
 
inline OpBuilder op_builder(coco::Module *m) { return OpBuilder{m}; }
inline OpBuilder op_builder(const std::unique_ptr<coco::Module> &m) { return op_builder(m.get()); }
 
class InstrBuilder
{
public:
  InstrBuilder(coco::Module *module) : _module{module}
  {
    // NOTE _module SHOULD be valid
    assert(_module != nullptr);
  }
 
public:
  coco::Eval *eval(coco::Object *out, coco::Op *op) const
  {
    auto ins = _module->entity()->instr()->create<coco::Eval>();
    ins->op(op);
    ins->out(out);
    return ins;
  }
 
  coco::Copy *copy(coco::Object *into, coco::Object *from) const
  {
    auto ins = _module->entity()->instr()->create<coco::Copy>();
    ins->from(from);
    ins->into(into);
    return ins;
  }
 
private:
  coco::Module *_module;
};
 
using ModuleHandle = std::unique_ptr<coco::Module>;
 
inline InstrBuilder instr_builder(coco::Module *m) { return InstrBuilder{m}; }
inline InstrBuilder instr_builder(const ModuleHandle &m) { return instr_builder(m.get()); }
 
#endif // __IR_BUILDER_H__