blob: 13d47ac7173ce61504d1bfb5a83d59eb0ed6fa15 [file] [log] [blame]
//===-- go-llvm-bnode.cpp - implementation of 'Bnode' class ---------------===//
//
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
//
//===----------------------------------------------------------------------===//
//
// Methods for class Bnode and related classes.
//
//===----------------------------------------------------------------------===//
#include "go-llvm.h"
#include "go-llvm-btype.h"
#include "go-llvm-bnode.h"
#include "go-llvm-bvariable.h"
#include "go-llvm-bexpression.h"
#include "go-llvm-bstatement.h"
#include "go-llvm-tree-integrity.h"
#include "go-system.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/Value.h"
// Table of Bnode properties
enum StmtDisp : unsigned char { IsStmt, IsExpr };
struct BnodePropVals {
const char *str;
unsigned numChildren;
StmtDisp stmt;
};
static constexpr unsigned Variadic = 0xffffffff;
static BnodePropVals BnodeProperties[] = {
/* N_Error */ { "error", 0, IsExpr },
/* N_Const */ { "const", 0, IsExpr },
/* N_Var */ { "var", 0, IsExpr },
/* N_FcnAddress */ { "fcn", 0, IsExpr },
/* N_LabelAddress */ { "labelad", 0, IsExpr },
/* N_Conversion */ { "conv", 1, IsExpr },
/* N_Deref */ { "deref", 1, IsExpr },
/* N_Address */ { "addr", 1, IsExpr },
/* N_UnaryOp */ { "unary", 1, IsExpr },
/* N_StructField */ { "field", 1, IsExpr },
/* N_BinaryOp */ { "binary", 2, IsExpr },
/* N_Compound */ { "compound", 2, IsExpr },
/* N_ArrayIndex */ { "arindex", 2, IsExpr },
/* N_PointerOffset */ { "ptroff", 2, IsExpr },
/* N_Composite */ { "composite", Variadic, IsExpr },
/* N_Call */ { "call", Variadic, IsExpr },
/* N_Conditional */ { "conditional", Variadic, IsExpr },
/* N_EmptyStmt */ { "empty", 0, IsStmt },
/* N_LabelStmt */ { "label", 0, IsStmt },
/* N_GotoStmt */ { "goto", 0, IsStmt },
/* N_ExprStmt */ { "exprst", 1, IsStmt },
/* N_ReturnStmt */ { "return", 1, IsStmt },
/* N_DeferStmt */ { "defer", 2, IsStmt },
/* N_IfStmt */ { "ifstmt", 3, IsStmt },
/* N_ExcepStmt */ { "excepstmt", 3, IsStmt },
/* N_BlockStmt */ { "block", Variadic, IsStmt },
/* N_SwitchStmt */ { "switch", Variadic, IsStmt }
};
Bnode::Bnode(NodeFlavor flavor, const std::vector<Bnode *> &kids, Location loc)
: kids_(kids)
, location_(loc)
, flavor_(flavor)
, id_(0xfeedface)
, flags_(0)
{
memset(&u, '\0', sizeof(u));
assert(BnodeProperties[flavor].numChildren == Variadic ||
BnodeProperties[flavor].numChildren == kids.size());
}
Bnode::Bnode(const Bnode &src)
: location_(src.location_)
, flavor_(src.flavor_)
, id_(0xfeedface)
, flags_(0)
{
assert(! isStmt());
memcpy(&u, &src.u, sizeof(u));
}
Bexpression *Bnode::castToBexpression() const {
if (isStmt())
return nullptr;
return const_cast<Bexpression*>(static_cast<const Bexpression*>(this));
}
Bstatement *Bnode::castToBstatement() const {
if (!isStmt())
return nullptr;
return const_cast<Bstatement*>(static_cast<const Bstatement*>(this));
}
Bblock *Bnode::castToBblock() const {
if (flavor() != N_BlockStmt)
return nullptr;
return const_cast<Bblock*>(static_cast<const Bblock*>(this));
}
void Bnode::replaceChild(unsigned idx, Bnode *newchild)
{
assert(idx < kids_.size());
kids_[idx] = newchild;
}
static const char *opToString(Operator op)
{
switch(op) {
case OPERATOR_INVALID: return "<invalid>";
case OPERATOR_OROR: return "||"; // ||
case OPERATOR_ANDAND: return "&&"; // &&
case OPERATOR_EQEQ: return "=="; // ==
case OPERATOR_NOTEQ: return "!="; // !=
case OPERATOR_LT: return "<"; // <
case OPERATOR_LE: return "<="; // <=
case OPERATOR_GT: return ">"; // >
case OPERATOR_GE: return ">="; // >=
case OPERATOR_PLUS: return "+"; // +
case OPERATOR_MINUS: return "-"; // -
case OPERATOR_OR: return "|"; // |
case OPERATOR_XOR: return "^"; // ^
case OPERATOR_MULT: return "*"; // *
case OPERATOR_DIV: return "/"; // /
case OPERATOR_MOD: return "%"; // %
case OPERATOR_LSHIFT: return "<<"; // <<
case OPERATOR_RSHIFT: return ">>"; // >>
case OPERATOR_AND: return "&"; // &
case OPERATOR_NOT: return "!"; // !
case OPERATOR_EQ: return "="; // =
case OPERATOR_BITCLEAR: return "&^";// &^
default: break;
}
assert(false && "operator unhandled");
return "";
}
const char *Bnode::flavstr() const {
if (flavor() == N_UnaryOp || flavor() == N_BinaryOp)
return opToString(u.op);
return BnodeProperties[flavor()].str;
}
static void indent(llvm::raw_ostream &os, unsigned ilevel) {
for (unsigned i = 0; i < ilevel; ++i)
os << " ";
}
void Bnode::dump()
{
std::string s;
llvm::raw_string_ostream os(s);
osdump(os, 0, nullptr, false);
std::cerr << os.str();
}
void Bnode::osdump(llvm::raw_ostream &os, unsigned ilevel,
Llvm_linemap *linemap, bool terse)
{
if (! terse) {
if (linemap) {
indent(os, ilevel);
os << linemap->to_string(location()) << "\n";
linemap = nullptr; // just want top-level src, not src for all kids
}
}
// Basic description of node
indent(os, ilevel);
os << flavstr() << ": ";
// Additional info
const Bexpression *expr = castToBexpression();
if (expr) {
// expression type
os << "[ btype: ";
expr->btype()->osdump(os, 0);
os << " ] ";
}
switch(flavor()) {
case N_Error: {
os << "\n";
return;
}
case N_Const: {
assert(expr);
if (expr->value())
expr->value()->print(os);
else
os << "<nil const>";
os << "\n";
return;
}
case N_Composite: {
assert(expr);
if (expr->value() && llvm::isa<llvm::Constant>(expr->value())) {
expr->value()->print(os);
os << "\n";
return;
}
break;
}
case N_FcnAddress: {
assert(expr);
if (llvm::isa<llvm::Function>(expr->value())) {
llvm::Function *f = llvm::cast<llvm::Function>(expr->value());
os << f->getName() << "\n";
return;
}
break;
}
case N_LabelAddress: {
assert(expr);
os << "label_addr " << u.label->label();
break;
}
case N_Var: {
os << "'" << u.var->name() << "' type: ";
u.var->btype()->osdump(os, 0);
break;
}
case N_StructField: {
os << "field " << u.fieldIndex;
break;
}
case N_BlockStmt: {
Bblock *block = castToBblock();
if (block->vars().size()) {
os << " { ";
unsigned tmps = 0;
for (auto &v : block->vars()) {
if (v->isTemporary()) {
tmps += 1;
continue;
}
os << v->name() << " ";
}
os << "} ";
if (tmps)
os << tmps << " tmps";
}
break;
}
case N_LabelStmt:
case N_GotoStmt: {
os << "label " << u.label->label();
break;
}
default: break;
}
if (!terse && expr && expr->varExprPending()) {
const VarContext &vc = expr->varContext();
os << " [VP lvalue=" << (vc.lvalue() ? "yes" : "no")
<< " addrLevel=" << vc.addrLevel() << "]";
}
os << "\n";
if (expr)
expr->dumpInstructions(os, ilevel, linemap, terse);
// Now children
for (auto &kid : kids_)
kid->osdump(os, ilevel + 2, linemap, terse);
}
void BnodeBuilder::destroy(Bnode *node, WhichDel which, bool recursive)
{
std::set<Bnode *> visited;
destroyRec(node, which, recursive, visited);
}
void BnodeBuilder::destroyRec(Bnode *node,
WhichDel which,
bool recursive,
std::set<Bnode *> &visited)
{
if (visited.find(node) != visited.end())
return;
visited.insert(node);
if (which != DelWrappers) {
Bexpression *expr = node->castToBexpression();
if (expr) {
unsigned idx = 0;
for (auto inst : expr->instructions()) {
integrityVisitor_->unsetParent(inst, expr, idx);
inst->dropAllReferences();
idx++;
}
for (auto inst : expr->instructions())
recordDeadInstruction(inst);
expr->clear();
}
}
if (recursive)
for (auto &kid : node->kids_)
destroyRec(kid, which, true, visited);
if (which != DelInstructions)
freeNode(node);
}
void BnodeBuilder::recordDeadInstruction(llvm::Instruction *inst)
{
assert(!inst->getParent());
deadInstructions_.push_back(inst);
}
SwitchDescriptor *Bnode::getSwitchCases()
{
assert(flavor() == N_SwitchStmt);
assert(u.swcases);
return u.swcases;
}
Blabel *Bnode::label() const
{
assert(flavor() == N_LabelStmt || flavor() == N_GotoStmt ||
flavor() == N_LabelAddress);
return u.label;
}
Operator Bnode::op() const
{
assert(flavor() == N_UnaryOp || flavor() == N_BinaryOp);
return u.op;
}
Bvariable *Bnode::var() const
{
assert(flavor() == N_Var || flavor() == N_ExcepStmt);
return u.var;
}
unsigned Bnode::fieldIndex() const
{
assert(flavor() == N_StructField);
return u.fieldIndex;
}
Bfunction *Bnode::getFunction() const
{
assert(flavor() == N_FcnAddress ||
flavor() == N_Call ||
flavor() == N_Conditional);
return u.func;
}
Bfunction *Bnode::getCallTarget() const
{
assert(flavor() == N_Call);
if (kids_[0]->flavor() == N_FcnAddress)
return kids_[0]->getFunction();
return nullptr;
}
int Bnode::getIndices() const
{
assert(flavor() == N_Composite);
return u.indices;
}
//......................................................................
BnodeBuilder::BnodeBuilder(Llvm_backend *be)
: integrityVisitor_(new IntegrityVisitor(be, TreeIntegCtl(DumpPointers, DontReportRepairableSharing, IncrementalMode)))
, checkIntegrity_(true)
, addressSpace_(be->addressSpace())
{
}
// A note on the llvm::Instruction deletions below: ordinarily, the
// expectation would be that any expressions encountered in the
// earchive_ loop below would already have had their instructions
// transferred to some basic block. If errors were encountered during
// the compilation, however there may be unparented expressions whose
// instructions are left dangling. If so, we want to delete them here
// so as to avoid asserts in the llvmContext destructor.
BnodeBuilder::~BnodeBuilder()
{
freeStmts();
std::vector<llvm::Instruction *> todel;
for (auto &expr : earchive_) {
if (expr) {
for (auto inst : expr->instructions()) {
if (inst->getParent() == nullptr) {
inst->dropAllReferences();
todel.push_back(inst);
}
}
delete expr;
}
}
for (auto ivpair : tempvars_) {
llvm::Instruction *inst = ivpair.first;
if (auto *ascast = llvm::dyn_cast<llvm::AddrSpaceCastInst>(inst)) {
inst = llvm::cast<llvm::Instruction>(ascast->getPointerOperand());
ascast->dropAllReferences();
todel.push_back(ascast);
}
assert(llvm::isa<llvm::AllocaInst>(inst));
todel.push_back(inst);
delete ivpair.second;
}
for (auto v : todel)
v->deleteValue();
for (auto inst : deadInstructions_)
inst->deleteValue();
}
void BnodeBuilder::freeStmts()
{
for (auto &stmt : sarchive_) {
if (stmt)
delete stmt;
}
sarchive_.clear();
for (auto &c : swcases_)
delete c;
swcases_.clear();
}
void BnodeBuilder::freeNode(Bnode *node)
{
assert(node);
Bexpression *expr = node->castToBexpression();
if (expr) {
earchive_[expr->id()] = nullptr;
if (expr->id() == earchive_.size()-1)
earchive_.pop_back();
delete expr;
} else {
Bstatement *stmt = node->castToBstatement();
sarchive_[stmt->id()] = nullptr;
if (stmt->id() == sarchive_.size()-1)
sarchive_.pop_back();
delete stmt;
}
}
void BnodeBuilder::checkTreeInteg(Bnode *node)
{
if (checkIntegrity_ && !integrityVisitor_->examine(node)) {
std::cerr << integrityVisitor_->msg();
assert(false);
}
}
Bexpression *BnodeBuilder::archive(Bexpression *expr)
{
expr->id_ = earchive_.size();
earchive_.push_back(expr);
checkTreeInteg(expr);
return expr;
}
Bstatement *BnodeBuilder::archive(Bstatement *stmt)
{
stmt->id_ = sarchive_.size();
sarchive_.push_back(stmt);
checkTreeInteg(stmt);
return stmt;
}
Bblock *BnodeBuilder::archive(Bblock *bb)
{
Bstatement *stmt = bb;
return static_cast<Bblock*>(archive(stmt));
}
Bexpression *BnodeBuilder::mkError(Btype *errortype)
{
std::vector<Bnode *> kids;
Location loc;
llvm::Value *noval = nullptr;
return archive(new Bexpression(N_Error, kids, noval, errortype, loc));
}
Bexpression *BnodeBuilder::mkConst(Btype *btype, llvm::Value *value)
{
assert(btype);
assert(value);
std::vector<Bnode *> kids;
Location loc;
return archive(new Bexpression(N_Const, kids, value, btype, loc));
}
Bexpression *BnodeBuilder::mkVoidValue(Btype *btype)
{
assert(btype);
std::vector<Bnode *> kids;
Location loc;
return archive(new Bexpression(N_Const, kids, nullptr, btype, loc));
}
Bexpression *BnodeBuilder::mkVar(Bvariable *var, llvm::Value *val, Location loc)
{
assert(var);
Btype *vt = var->btype();
std::vector<Bnode *> kids;
Bexpression *rval =
new Bexpression(N_Var, kids, val, vt, loc);
rval->u.var = var;
return archive(rval);
}
Bvariable *BnodeBuilder::mkTempVar(Btype *varType,
TypeManager *tm,
Location loc,
const std::string &name)
{
assert(varType);
llvm::Type *typ = varType->type();
llvm::Instruction *insBefore = nullptr;
llvm::Align aaAlign = tm->datalayout()->getABITypeAlign(typ);
llvm::Value *aaSize = nullptr;
llvm::Instruction *inst = new llvm::AllocaInst(typ, 0, aaSize, aaAlign,
name, insBefore);
Bvariable *tvar = new Bvariable(varType, loc, name, LocalVar, true, inst);
tempvars_[inst] = tvar;
tvar->markAsTemporary();
return tvar;
}
Bvariable *BnodeBuilder::adoptTemporaryVariable(llvm::Instruction *alloca)
{
assert(alloca);
auto mit = tempvars_.find(alloca);
if (mit == tempvars_.end())
return nullptr;
Bvariable *ret = mit->second;
tempvars_.erase(mit);
return ret;
}
// This is somewhat unpleasant but necessary due to the way LLVM's
// IRBuilder works. If you do something like
//
// newinst = builder.CreateOr(left, right)
//
// and it turns out that 'right' is the constant zero, then the
// builder will just return left (meaning that we don't want the
// instruction to be appended to the new Bexpression).
void BnodeBuilder::appendInstIfNeeded(Bexpression *rval, llvm::Value *val)
{
if (val == nullptr || !llvm::isa<llvm::Instruction>(val))
return;
llvm::Instruction *inst = llvm::cast<llvm::Instruction>(val);
for (auto &kid : rval->kids_) {
Bexpression *expr = kid->castToBexpression();
if (expr && expr->value() == inst)
return;
}
rval->appendInstruction(inst);
}
Bexpression *BnodeBuilder::mkBinaryOp(Operator op, Btype *typ, llvm::Value *val,
Bexpression *left, Bexpression *right,
Location loc)
{
assert(left);
assert(right);
std::vector<Bnode *> kids = { left, right };
Bexpression *rval =
new Bexpression(N_BinaryOp, kids, val, typ, loc);
if (val)
appendInstIfNeeded(rval, val);
rval->u.op = op;
return archive(rval);
}
Bexpression *BnodeBuilder::mkBinaryOp(Operator op, Btype *typ, llvm::Value *val,
Bexpression *left, Bexpression *right,
Binstructions &instructions, Location loc)
{
assert(left);
assert(right);
std::vector<Bnode *> kids = { left, right };
Bexpression *rval =
new Bexpression(N_BinaryOp, kids, val, typ, loc);
for (auto &inst : instructions.instructions())
rval->appendInstruction(inst);
rval->u.op = op;
return archive(rval);
}
Bexpression *BnodeBuilder::mkUnaryOp(Operator op, Btype *typ, llvm::Value *val,
Bexpression *src, Location loc)
{
assert(src);
std::vector<Bnode *> kids = { src };
Bexpression *rval =
new Bexpression(N_UnaryOp, kids, val, typ, loc);
rval->u.op = op;
appendInstIfNeeded(rval, val);
return archive(rval);
}
Bexpression *BnodeBuilder::mkConversion(Btype *typ, llvm::Value *val,
Bexpression *src, Location loc)
{
std::vector<Bnode *> kids = { src };
Bexpression *rval =
new Bexpression(N_Conversion, kids, val, typ, loc);
appendInstIfNeeded(rval, val);
return archive(rval);
}
Bexpression *BnodeBuilder::mkAddress(Btype *typ, llvm::Value *val,
Bexpression *src, Location loc)
{
std::vector<Bnode *> kids = { src };
Bexpression *rval = new Bexpression(N_Address, kids, val, typ, loc);
appendInstIfNeeded(rval, val);
return archive(rval);
}
Bexpression *BnodeBuilder::mkFcnAddress(Btype *typ, llvm::Value *val,
Bfunction *func, Location loc)
{
std::vector<Bnode *> kids;
Bexpression *rval = new Bexpression(N_FcnAddress, kids, val, typ, loc);
rval->u.func = func;
return archive(rval);
}
Bexpression *BnodeBuilder::mkLabelAddress(Btype *typ,
llvm::Value *val,
Blabel *label,
Location loc)
{
std::vector<Bnode *> kids;
Bexpression *rval = new Bexpression(N_LabelAddress, kids, val, typ, loc);
rval->u.label = label;
return archive(rval);
}
Bexpression *BnodeBuilder::mkDeref(Btype *typ, llvm::Value *val,
Bexpression *src, Location loc)
{
std::vector<Bnode *> kids = { src };
Bexpression *rval = new Bexpression(N_Deref, kids, val, typ, loc);
return archive(rval);
}
Bexpression *
BnodeBuilder::mkIndexedComposite(Btype *btype,
llvm::Value *value,
const std::vector<Bexpression *> &vals,
const std::vector<unsigned long> &indices,
Binstructions &instructions,
Location loc)
{
std::vector<Bnode *> kids;
for (auto &v : vals)
kids.push_back(v);
Bexpression *rval =
new Bexpression(N_Composite, kids, value, btype, loc);
for (auto &inst : instructions.instructions())
rval->appendInstruction(inst);
indexvecs_.push_back(indices);
rval->u.indices = indexvecs_.size() - 1;
return archive(rval);
}
Bexpression *
BnodeBuilder::mkComposite(Btype *btype,
llvm::Value *value,
const std::vector<Bexpression *> &vals,
Binstructions &instructions,
Location loc)
{
std::vector<Bnode *> kids;
for (auto &v : vals)
kids.push_back(v);
Bexpression *rval =
new Bexpression(N_Composite, kids, value, btype, loc);
for (auto &inst : instructions.instructions())
rval->appendInstruction(inst);
rval->u.indices = -1;
return archive(rval);
}
Bexpression *BnodeBuilder::mkStructField(Btype *typ,
llvm::Value *val,
Bexpression *structval,
unsigned fieldIndex,
Location loc)
{
std::vector<Bnode *> kids = { structval };
Bexpression *rval =
new Bexpression(N_StructField, kids, val, typ, loc);
appendInstIfNeeded(rval, val);
rval->u.fieldIndex = fieldIndex;
return archive(rval);
}
Bexpression *BnodeBuilder::mkArrayIndex(Btype *typ,
llvm::Value *val,
Bexpression *arval,
Bexpression *index,
Location loc)
{
std::vector<Bnode *> kids = { arval, index };
Bexpression *rval =
new Bexpression(N_ArrayIndex, kids, val, typ, loc);
appendInstIfNeeded(rval, val);
return archive(rval);
}
Bexpression *BnodeBuilder::mkPointerOffset(Btype *typ,
llvm::Value *val,
Bexpression *ptr,
Bexpression *offset,
Location loc)
{
std::vector<Bnode *> kids = { ptr, offset };
Bexpression *rval =
new Bexpression(N_PointerOffset, kids, val, typ, loc);
appendInstIfNeeded(rval, val);
return archive(rval);
}
Bexpression *BnodeBuilder::mkCompound(Bstatement *st,
Bexpression *expr,
llvm::Value *val,
Location loc)
{
std::vector<Bnode *> kids = { st, expr };
Bexpression *rval =
new Bexpression(N_Compound, kids, val, expr->btype(), loc);
rval->setTag(expr->tag());
return archive(rval);
}
static bool isAlloca(llvm::Value *val)
{
if (llvm::isa<llvm::AllocaInst>(val))
return true;
if (auto *ascast = llvm::dyn_cast<llvm::AddrSpaceCastInst>(val))
return llvm::isa<llvm::AllocaInst>(ascast->getPointerOperand());
return false;
}
Bexpression *BnodeBuilder::mkCall(Btype *btype,
llvm::Value *val,
Bfunction *caller,
Bexpression *fnExpr,
Bexpression *chainExpr,
const std::vector<Bexpression *> &args,
Binstructions &instructions,
Location loc)
{
std::vector<Bnode *> kids;
kids.push_back(fnExpr);
kids.push_back(chainExpr);
for (auto &a : args)
kids.push_back(a);
Bexpression *rval =
new Bexpression(N_Call, kids, val, btype, loc);
bool found = false;
for (auto &inst : instructions.instructions()) {
if (inst == val)
found = true;
rval->appendInstruction(inst);
}
if (!found && val && !isAlloca(val))
appendInstIfNeeded(rval, val);
rval->u.func = caller;
return archive(rval);
}
Bexpression *BnodeBuilder::mkConditional(Bfunction *function,
Btype *btype,
Bexpression *condition,
Bexpression *then_expr,
Bexpression *else_expr,
Location loc)
{
std::vector<Bnode *> kids;
kids.push_back(condition);
kids.push_back(then_expr);
if (else_expr)
kids.push_back(else_expr);
Bexpression *rval =
new Bexpression(N_Conditional, kids, nullptr, btype, loc);
rval->u.func = function;
return archive(rval);
}
Bstatement *BnodeBuilder::mkErrorStmt()
{
assert(! errorStatement_.get());
std::vector<Bnode *> kids;
errorStatement_.reset(new Bstatement(N_Error, nullptr, kids, Location()));
return errorStatement_.get();
}
Bstatement *BnodeBuilder::mkExprStmt(Bfunction *func,
Bexpression *expr,
Location loc)
{
std::vector<Bnode *> kids = { expr };
Bstatement *rval = new Bstatement(N_ExprStmt, func, kids, loc);
return archive(rval);
}
Bstatement *BnodeBuilder::mkReturn(Bfunction *func,
Bexpression *returnVal,
Location loc)
{
std::vector<Bnode *> kids = { returnVal };
Bstatement *rval = new Bstatement(N_ReturnStmt, func, kids, loc);
return archive(rval);
}
Bstatement *BnodeBuilder::mkLabelDefStmt(Bfunction *func,
Blabel *label,
Location loc)
{
std::vector<Bnode *> kids;
Bstatement *rval = new Bstatement(N_LabelStmt, func, kids, loc);
rval->u.label = label;
return archive(rval);
}
Bstatement *BnodeBuilder::mkGotoStmt(Bfunction *func,
Blabel *label,
Location loc)
{
std::vector<Bnode *> kids;
Bstatement *rval = new Bstatement(N_GotoStmt, func, kids, loc);
rval->u.label = label;
return archive(rval);
}
Bstatement *BnodeBuilder::mkIfStmt(Bfunction *func,
Bexpression *cond, Bblock *trueBlock,
Bblock *falseBlock, Location loc)
{
if (falseBlock == nullptr)
falseBlock = mkBlock(func, std::vector<Bvariable *>(), loc);
std::vector<Bnode *> kids = { cond, trueBlock, falseBlock };
Bstatement *rval = new Bstatement(N_IfStmt, func, kids, loc);
return archive(rval);
}
Bstatement *BnodeBuilder::mkDeferStmt(Bfunction *func,
Bexpression *undefer,
Bexpression *defer,
Location loc)
{
assert(func);
assert(undefer);
assert(defer);
std::vector<Bnode *> kids = { undefer, defer };
Bstatement *rval = new Bstatement(N_DeferStmt, func, kids, loc);
return archive(rval);
}
Bstatement *BnodeBuilder::mkExcepStmt(Bfunction *func,
Bstatement *body,
Bstatement *onexception,
Bstatement *finally,
Bvariable *finTempVar,
Location loc)
{
assert(body);
assert(onexception);
assert(finally);
assert(finTempVar);
std::vector<Bnode *> kids = { body, onexception, finally };
Bstatement *rval = new Bstatement(N_ExcepStmt, func, kids, loc);
rval->u.var = finTempVar;
return archive(rval);
}
SwitchDescriptor::SwitchDescriptor(const std::vector<std::vector<Bexpression *> > &vals)
{
// Determine child index of first stmt
unsigned stidx = 1;
for (auto &vvec : vals)
stidx += vvec.size();
// Construct case descriptors
unsigned idx = 1;
for (auto &vvec : vals) {
cases_.push_back(SwitchCaseDesc(idx, vvec.size(), stidx++));
idx += vvec.size();
}
}
Bstatement *BnodeBuilder::mkSwitchStmt(Bfunction *func,
Bexpression *swvalue,
const std::vector<std::vector<Bexpression *> > &vals,
const std::vector<Bstatement *> &stmts,
Location loc)
{
std::vector<Bnode *> kids = { swvalue };
for (auto &vvec : vals)
for (auto &v : vvec)
kids.push_back(v);
for (auto &st : stmts)
// For cases that has only a fallthrough statement, the FE passes a null
// block. Having a null node in the tree may cause various problems.
// Make an empty block instead.
kids.push_back(st ? st : mkBlock(func, {}, loc));
SwitchDescriptor *d = new SwitchDescriptor(vals);
swcases_.push_back(d);
Bstatement *rval = new Bstatement(N_SwitchStmt, func, kids, loc);
rval->u.swcases = d;
return archive(rval);
}
Bblock *BnodeBuilder::mkBlock(Bfunction *func,
const std::vector<Bvariable *> &vars,
Location loc)
{
Bblock *rval = new Bblock(func, vars, loc);
return archive(rval);
}
void BnodeBuilder::addStatementToBlock(Bblock *block, Bstatement *st)
{
assert(block);
assert(st);
block->kids_.push_back(st);
}
Bexpression *
BnodeBuilder::cloneSub(Bexpression *expr,
std::map<llvm::Value *, llvm::Value *> &vm)
{
assert(expr);
std::vector<Bnode *> newChildren;
for (auto &c : expr->children()) {
assert(c);
Bexpression *ce = c->castToBexpression();
assert(ce);
Bexpression *clc = cloneSubtree(ce);
newChildren.push_back(clc);
}
Bexpression *res = new Bexpression(*expr);
res->kids_ = newChildren;
archive(res);
llvm::Value *iv = expr->value();
llvm::Value *newv = nullptr;
for (auto inst : expr->instructions()) {
if (inst == iv) {
assert(! newv);
newv = inst;
}
llvm::Instruction *icl = inst->clone();
unsigned nops = inst->getNumOperands();
for (unsigned idx = 0; idx < nops; ++idx) {
llvm::Value *v = inst->getOperand(idx);
auto it = vm.find(v);
if (it != vm.end()) {
llvm::Value *cv = it->second;
icl->setOperand(idx, cv);
}
}
icl->setName(inst->getName());
res->appendInstruction(icl);
}
if (newv)
res->setValue(newv);
return res;
}
Bexpression *BnodeBuilder::cloneSubtree(Bexpression *expr) {
std::map<llvm::Value *, llvm::Value *> vm;
return cloneSub(expr, vm);
}
std::vector<Bexpression *>
BnodeBuilder::extractChildenAndDestroy(Bexpression *expr)
{
assert(expr);
assert(expr->value() == nullptr);
assert(expr->instructions().empty());
std::vector<Bexpression *> orphanExprs;
std::vector<Bnode *> orphanNodes = extractChildNodesAndDestroy(expr);
for (auto k : orphanNodes) {
Bexpression *ekid = k->castToBexpression();
assert(ekid);
orphanExprs.push_back(ekid);
}
return orphanExprs;
}
std::vector<Bnode *>
BnodeBuilder::extractChildNodesAndDestroy(Bnode *node)
{
std::vector<Bnode *> orphans;
assert(node);
for (unsigned idx = 0; idx < node->kids_.size(); ++idx) {
Bnode *kid = node->kids_[idx];
integrityVisitor_->unsetParent(kid, node, idx);
orphans.push_back(kid);
}
integrityVisitor_->deletePending(node);
Bexpression *expr = node->castToBexpression();
assert(expr); // statements not yet supported, could be if needed
freeNode(expr);
return orphans;
}
const std::vector<unsigned long> *BnodeBuilder::getIndices(Bexpression *expr) const
{
int i = expr->getIndices();
if (i < 0)
return nullptr;
assert((unsigned)i < indexvecs_.size());
return &indexvecs_[i];
}
void BnodeBuilder::updateInstructions(Bexpression *expr,
std::vector<llvm::Instruction*> newinsts)
{
assert(expr->instructions().size() >= newinsts.size());
llvm::Instruction *deleteAfter = nullptr;
unsigned newSize = newinsts.size();
unsigned idx = 0;
for (auto originst : expr->instructions()) {
if (idx >= newSize) {
if (idx == newSize)
deleteAfter = originst;
integrityVisitor_->unsetParent(originst, expr, idx);
} else {
llvm::Instruction *newinst = newinsts[idx];
if (originst != newinst) {
integrityVisitor_->unsetParent(originst, expr, idx);
integrityVisitor_->setParent(newinst, expr, idx);
if (expr->value() == originst)
expr->setValue(newinst);
}
}
idx++;
}
if (deleteAfter != nullptr) {
std::vector<llvm::Instruction *> todel =
expr->extractInstsAfter(deleteAfter);
for (auto it = todel.rbegin(); it != todel.rend(); ++it) {
auto victim = *it;
victim->deleteValue();
}
}
}
void BnodeBuilder::updateValue(Bexpression *expr, llvm::Value *newValue)
{
assert(expr != NULL && newValue != NULL && expr->value() != NULL);
// New value should be different from old value
assert(expr->value() != newValue);
// Types should match
assert(expr->value()->getType() == newValue->getType());
expr->setValue(newValue);
}