| //===-- hlvm/AST/Operator.cpp - AST Operator Class --------------*- C++ -*-===// |
| // |
| // High Level Virtual Machine (HLVM) |
| // |
| // Copyright (C) 2006 Reid Spencer. All Rights Reserved. |
| // |
| // This software is free software; you can redistribute it and/or modify it |
| // under the terms of the GNU Lesser General Public License as published by |
| // the Free Software Foundation; either version 2.1 of the License, or (at |
| // your option) any later version. |
| // |
| // This software is distributed in the hope that it will be useful, but WITHOUT |
| // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
| // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for |
| // more details. |
| // |
| // You should have received a copy of the GNU Lesser General Public License |
| // along with this library in the file named LICENSE.txt; if not, write to the |
| // Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
| // MA 02110-1301 USA |
| // |
| //===----------------------------------------------------------------------===// |
| /// @file hlvm/AST/Operator.cpp |
| /// @author Reid Spencer <reid@hlvm.org> (original author) |
| /// @date 2006/05/04 |
| /// @since 0.1.0 |
| /// @brief Implements the functions of class hlvm::AST::Operator. |
| //===----------------------------------------------------------------------===// |
| |
| #include <hlvm/AST/Operator.h> |
| #include <hlvm/AST/Linkables.h> |
| #include <hlvm/AST/Bundle.h> |
| #include <hlvm/AST/ControlFlow.h> |
| #include <hlvm/AST/MemoryOps.h> |
| #include <hlvm/Base/Assert.h> |
| #include <llvm/Support/Casting.h> |
| |
| using namespace llvm; |
| |
| namespace hlvm { |
| |
| Operator::~Operator() |
| { |
| } |
| |
| Function* |
| Operator::getContainingFunction() const |
| { |
| Node* p = getParent(); |
| while (p && !p->isFunction()) p = p->getParent(); |
| if (!p) |
| return 0; |
| return cast<Function>(p); |
| } |
| |
| Block* |
| Operator::getContainingBlock() const |
| { |
| Node* p = getParent(); |
| while (p && !isa<Block>(p)) p = p->getParent(); |
| if (!p) |
| return 0; |
| return cast<Block>(p); |
| } |
| |
| Operator* |
| Operator::getContainingLoop() const |
| { |
| Node* p = getParent(); |
| while (p && !p->isLoop()) p = p->getParent(); |
| if (!p) |
| return 0; |
| return cast<Operator>(p); |
| } |
| |
| NilaryOperator::~NilaryOperator() |
| { |
| } |
| |
| Operator* |
| NilaryOperator::getOperand(unsigned idx) const |
| { |
| hlvmAssert(!"Can't get operands from a NilaryOperator"); |
| return 0; |
| } |
| |
| size_t |
| NilaryOperator::getNumOperands() const |
| { |
| return 0; |
| } |
| |
| void |
| NilaryOperator::setOperand(unsigned opnum, Operator* operand) |
| { |
| hlvmAssert(!"Can't set operands on a NilaryOperator!"); |
| } |
| |
| void |
| NilaryOperator::insertChild(Node* child) |
| { |
| hlvmAssert(!"NilaryOperators don't accept children"); |
| } |
| |
| void |
| NilaryOperator::removeChild(Node* child) |
| { |
| hlvmAssert(!"Can't remove from a NilaryOperator"); |
| } |
| |
| UnaryOperator::~UnaryOperator() |
| { |
| } |
| |
| Operator* |
| UnaryOperator::getOperand(unsigned idx) const |
| { |
| assert(idx == 0 && "Operand index out of range"); |
| return op1; |
| } |
| |
| size_t |
| UnaryOperator::getNumOperands() const |
| { |
| return op1 != 0; |
| } |
| |
| void |
| UnaryOperator::setOperand(unsigned opnum, Operator* operand) |
| { |
| hlvmAssert(opnum == 0 && "Operand Index out of range for UnaryOperator!"); |
| operand->setParent(this); |
| } |
| |
| void |
| UnaryOperator::insertChild(Node* child) |
| { |
| hlvmAssert(isa<Operator>(child)); |
| hlvmAssert(child != op1 && "Re-insertion of child"); |
| if (!op1) |
| op1 = cast<Operator>(child); |
| else |
| hlvmAssert("UnaryOperator full"); |
| } |
| |
| void |
| UnaryOperator::removeChild(Node* child) |
| { |
| hlvmAssert(isa<Operator>(child)); |
| if (op1 == child) { |
| op1 = 0; |
| } else |
| hlvmAssert(!"Can't remove child from UnaryOperator"); |
| } |
| |
| void |
| UnaryOperator::resolveTypeTo(const Type* from, const Type* to) |
| { |
| Operator::resolveTypeTo(from,to); |
| if(op1) |
| op1->resolveTypeTo(from,to); |
| } |
| |
| BinaryOperator::~BinaryOperator() |
| { |
| } |
| |
| Operator* |
| BinaryOperator::getOperand(unsigned idx) const |
| { |
| assert(idx <= 1 && "Operand index out of range"); |
| return ops[idx]; |
| } |
| |
| size_t |
| BinaryOperator::getNumOperands() const |
| { |
| return (ops[0] ? 1 : 0) + (ops[1] ? 1 : 0); |
| } |
| |
| void |
| BinaryOperator::setOperand(unsigned opnum, Operator* operand) |
| { |
| hlvmAssert(opnum <= 1 && "Operand Index out of range for BinaryOperator!"); |
| operand->setParent(this); |
| } |
| |
| void |
| BinaryOperator::insertChild(Node* child) |
| { |
| hlvmAssert(isa<Operator>(child)); |
| hlvmAssert(child != ops[0] && child != ops[1] && "Re-insertion of child"); |
| if (!ops[0]) |
| ops[0] = cast<Operator>(child); |
| else if (!ops[1]) |
| ops[1] = cast<Operator>(child); |
| else |
| hlvmAssert(!"BinaryOperator full!"); |
| } |
| |
| void |
| BinaryOperator::removeChild(Node* child) |
| { |
| hlvmAssert(isa<Operator>(child)); |
| if (ops[0] == child) |
| ops[0] = 0; |
| else if (ops[1] == child) |
| ops[1] = 0; |
| else |
| hlvmAssert(!"Can't remove child from BinaryOperator"); |
| } |
| |
| void |
| BinaryOperator::resolveTypeTo(const Type* from, const Type* to) |
| { |
| Operator::resolveTypeTo(from,to); |
| if(ops[0]) |
| ops[0]->resolveTypeTo(from,to); |
| if(ops[1]) |
| ops[1]->resolveTypeTo(from,to); |
| |
| } |
| |
| TernaryOperator::~TernaryOperator() |
| { |
| } |
| |
| Operator* |
| TernaryOperator::getOperand(unsigned idx) const |
| { |
| assert(idx <= 2 && "Operand index out of range"); |
| return ops[idx]; |
| } |
| |
| size_t |
| TernaryOperator::getNumOperands() const |
| { |
| return (ops[0] ? 1 : 0) + (ops[1] ? 1 : 0) + (ops[2] ? 1 : 0); |
| } |
| |
| void |
| TernaryOperator::setOperand(unsigned opnum, Operator* operand) |
| { |
| hlvmAssert(opnum <= 2 && "Operand Index out of range for TernaryOperator!"); |
| operand->setParent(this); |
| } |
| |
| void |
| TernaryOperator::insertChild(Node* child) |
| { |
| hlvmAssert(isa<Operator>(child)); |
| hlvmAssert(child != ops[0] && child != ops[1] && child != ops[2] && |
| "Re-insertion of child"); |
| if (!ops[0]) |
| ops[0] = cast<Operator>(child); |
| else if (!ops[1]) |
| ops[1] = cast<Operator>(child); |
| else if (!ops[2]) |
| ops[2] = cast<Operator>(child); |
| else |
| hlvmAssert(!"TernaryOperator full!"); |
| } |
| |
| void |
| TernaryOperator::removeChild(Node* child) |
| { |
| hlvmAssert(isa<Operator>(child)); |
| if (ops[0] == child) |
| ops[0] = 0; |
| else if (ops[1] == child) |
| ops[1] = 0; |
| else if (ops[2] == child) |
| ops[2] = 0; |
| else |
| hlvmAssert(!"Can't remove child from TernaryOperator!"); |
| } |
| |
| void |
| TernaryOperator::resolveTypeTo(const Type* from, const Type* to) |
| { |
| Operator::resolveTypeTo(from,to); |
| if(ops[0]) |
| ops[0]->resolveTypeTo(from,to); |
| if(ops[1]) |
| ops[1]->resolveTypeTo(from,to); |
| if(ops[2]) |
| ops[2]->resolveTypeTo(from,to); |
| |
| } |
| |
| MultiOperator::~MultiOperator() |
| { |
| } |
| |
| Operator* |
| MultiOperator::getOperand(unsigned idx) const |
| { |
| assert(idx <= ops.size() && "Operand index out of range"); |
| return ops[idx]; |
| } |
| |
| size_t |
| MultiOperator::getNumOperands() const |
| { |
| return ops.size(); |
| } |
| |
| void |
| MultiOperator::setOperand(unsigned opnum, Operator* operand) |
| { |
| if (ops.capacity() < opnum + 1) |
| ops.resize(opnum+1); |
| operand->setParent(this); |
| } |
| |
| void |
| MultiOperator::addOperands(const OprndList& oprnds) |
| { |
| for (const_iterator I = oprnds.begin(), E = oprnds.end(); I != E; ++I ) |
| { |
| hlvmAssert(isa<Operator>(*I)); |
| (*I)->setParent(this); |
| } |
| } |
| |
| void |
| MultiOperator::insertChild(Node* child) |
| { |
| hlvmAssert(isa<Operator>(child)); |
| #ifdef HLVM_ASSERT |
| for (const_iterator I = begin(), E = end(); I != E; ++I) |
| hlvmAssert((*I) != child && "Re-insertion of child"); |
| #endif |
| ops.push_back(cast<Operator>(child)); |
| } |
| |
| void |
| MultiOperator::removeChild(Node* child) |
| { |
| hlvmAssert(isa<Operator>(child)); |
| for (iterator I = begin(), E = end(); I != E; ++I ) { |
| if (*I == child) { ops.erase(I); return; } |
| } |
| } |
| |
| void |
| MultiOperator::resolveTypeTo(const Type* from, const Type* to) |
| { |
| Operator::resolveTypeTo(from,to); |
| for (iterator I = begin(), E = end(); I != E; ++I ) |
| (*I)->resolveTypeTo(from,to); |
| } |
| |
| } |