2001-07-08 19:03:27 +00:00
|
|
|
//===-- iOperators.cpp - Implement the Binary & Unary Operators --*- C++ -*--=//
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
2001-07-08 19:03:27 +00:00
|
|
|
// This file implements the nontrivial binary & unary operator instructions.
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2001-07-08 19:03:27 +00:00
|
|
|
#include "llvm/iOperators.h"
|
2001-06-06 20:29:01 +00:00
|
|
|
#include "llvm/Type.h"
|
2002-01-20 22:54:45 +00:00
|
|
|
using std::cerr;
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2001-07-08 19:03:27 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// UnaryOperator Class
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2002-08-09 21:39:38 +00:00
|
|
|
UnaryOperator *UnaryOperator::create(UnaryOps Op, Value *Source,
|
|
|
|
const std::string &Name) {
|
2001-07-08 04:57:15 +00:00
|
|
|
switch (Op) {
|
2002-08-09 21:39:38 +00:00
|
|
|
case Not: return new GenericUnaryInst(Op, Source, Name);
|
2001-07-08 04:57:15 +00:00
|
|
|
default:
|
2002-01-20 22:54:45 +00:00
|
|
|
cerr << "Don't know how to Create UnaryOperator " << Op << "\n";
|
2001-07-08 04:57:15 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-07-08 19:03:27 +00:00
|
|
|
|
2001-07-08 04:57:15 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// BinaryOperator Class
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2001-07-07 20:17:23 +00:00
|
|
|
BinaryOperator *BinaryOperator::create(BinaryOps Op, Value *S1, Value *S2,
|
2002-01-20 22:54:45 +00:00
|
|
|
const std::string &Name) {
|
2001-06-25 07:33:13 +00:00
|
|
|
switch (Op) {
|
2001-06-27 23:36:49 +00:00
|
|
|
// Binary comparison operators...
|
|
|
|
case SetLT: case SetGT: case SetLE:
|
|
|
|
case SetGE: case SetEQ: case SetNE:
|
2001-07-07 20:17:23 +00:00
|
|
|
return new SetCondInst(Op, S1, S2, Name);
|
2001-06-25 07:33:13 +00:00
|
|
|
|
|
|
|
default:
|
2001-07-07 19:24:15 +00:00
|
|
|
return new GenericBinaryInst(Op, S1, S2, Name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-12-13 00:43:03 +00:00
|
|
|
// swapOperands - Exchange the two operands to this instruction. This
|
|
|
|
// instruction is safe to use on any binary instruction and does not
|
|
|
|
// modify the semantics of the instruction. If the instruction is
|
|
|
|
// order dependant (SetLT f.e.) the opcode is changed.
|
|
|
|
//
|
|
|
|
bool BinaryOperator::swapOperands() {
|
|
|
|
switch (getOpcode()) {
|
|
|
|
// Instructions that don't need opcode modification
|
|
|
|
case Add: case Mul:
|
|
|
|
case And: case Xor:
|
|
|
|
case Or:
|
|
|
|
case SetEQ: case SetNE:
|
|
|
|
break;
|
|
|
|
// Instructions that need opcode modification
|
|
|
|
case SetGT: iType = SetLT; break;
|
|
|
|
case SetLT: iType = SetGT; break;
|
|
|
|
case SetGE: iType = SetLE; break;
|
|
|
|
case SetLE: iType = SetGE; break;
|
|
|
|
// Error on the side of caution
|
|
|
|
default:
|
|
|
|
return true;
|
|
|
|
}
|
2002-01-20 22:54:45 +00:00
|
|
|
std::swap(Operands[0], Operands[1]);
|
2001-12-13 00:43:03 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2001-07-08 19:03:27 +00:00
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SetCondInst Class
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
SetCondInst::SetCondInst(BinaryOps opType, Value *S1, Value *S2,
|
2002-01-20 22:54:45 +00:00
|
|
|
const std::string &Name)
|
2001-06-06 20:29:01 +00:00
|
|
|
: BinaryOperator(opType, S1, S2, Name) {
|
|
|
|
|
|
|
|
OpType = opType;
|
|
|
|
setType(Type::BoolTy); // setcc instructions always return bool type.
|
|
|
|
|
|
|
|
// Make sure it's a valid type...
|
2001-07-07 19:24:15 +00:00
|
|
|
assert(getOpcodeName() != 0);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|