std::string StringMessage::doToString() const
{
std::string r;
r = "string[" + to_string(getString().size()) + "]=" + getString()
+ "; terminator[" + to_string(getTerminator().size()) + "]=" + getTerminator();
return r;
}
inline int64_t skipPattern(
in_type & istr,
uint64_t & codelen)
{
// decode pattern length
uint32_t const patlen = decodeUTF8(istr,codelen);
if ( patlen == getTerminator() )
{
return -1;
}
else
{
// decode flags
uint32_t const flags = decodeUTF8(istr,codelen);
// compute length of encoded pattern
uint32_t const skip = (flags&1)?((patlen+1)/2):(patlen+3)/4;
// skip pattern data
for ( uint64_t i = 0; i < skip; ++i )
istr.get();
codelen += skip;
return patlen;
}
}
inline int64_t skipPattern(
in_type & istr,
uint64_t & patlencodelen,
uint64_t & flagcodelen,
uint64_t & datalen
)
{
uint32_t const patlen = decodeUTF8(istr,patlencodelen);
if ( patlen == getTerminator() )
{
return -1;
}
else
{
uint32_t const flags = decodeUTF8(istr,flagcodelen);
uint32_t const skip = (flags&1)?((patlen+1)/2):(patlen+3)/4;
for ( uint64_t i = 0; i < skip; ++i )
istr.get();
datalen += skip;
return patlen;
}
}
static bool LiftBlockIntoFunction(TranslationContext &ctx) {
auto didError = false;
//first, either create or look up the LLVM basic block for this native
//block. we are either creating it for the first time, or, we are
//going to look up a blank block
auto block_name = ctx.natB->get_name();
auto curLLVMBlock = ctx.va_to_bb[ctx.natB->get_base()];
//then, create a basic block for every follow of this block, if we do not
//already have that basic block in our LLVM CFG
const auto &follows = ctx.natB->get_follows();
for (auto succ_block_va : follows) {
if (!ctx.va_to_bb.count(succ_block_va)) {
throw TErr(__LINE__, __FILE__, "Missing successor block!");
}
}
//now, go through each statement and translate it into LLVM IR
//statements that branch SHOULD be the last statement in a block
for (auto inst : ctx.natB->get_insts()) {
ctx.natI = inst;
switch (LiftInstIntoBlock(ctx, curLLVMBlock, true)) {
case ContinueBlock:
break;
case EndBlock:
case EndCFG:
goto done;
case TranslateErrorUnsupported:
didError = !IgnoreUnsupportedInsts;
goto done;
case TranslateError:
didError = true;
goto done;
}
}
done:
if (curLLVMBlock->getTerminator()) {
return didError;
}
// we may need to insert a branch inst to the successor
// if the block ended on a non-terminator (this happens since we
// may split blocks in cfg recovery to avoid code duplication)
if (follows.size() == 1) {
llvm::BranchInst::Create(ctx.va_to_bb[follows.front()], curLLVMBlock);
} else {
new llvm::UnreachableInst(curLLVMBlock->getContext(), curLLVMBlock);
}
return didError;
}
// Links blocks without a terminator to the next block
void LinkBlocksWithoutTerminator(CodeGenerator *codegen, Function *function) {
auto bb = function->getBasicBlockList().begin();
auto next = bb;
auto end = function->getBasicBlockList().end();
// Save the current insert block
BasicBlock *restorePoint = codegen->getBuilder().GetInsertBlock();
for (; bb != end && ++next != end; ++bb) {
if (bb->getTerminator() == nullptr) {
codegen->getBuilder().SetInsertPoint(bb);
codegen->getBuilder().CreateBr(next);
}
}
// Restore the insert point position.
codegen->getBuilder().SetInsertPoint(restorePoint);
}
llvm::Value * Generator::visit(If & node)
{
auto condition = node.condition->accept(this);
auto function = builder.GetInsertBlock()->getParent();
auto thenBlock = llvm::BasicBlock::Create(*context, "then", function);
auto elseBlock = llvm::BasicBlock::Create(*context, "else");
auto mergeBlock = llvm::BasicBlock::Create(*context, "ifcont");
if (node.elseBlock) {
builder.CreateCondBr(condition, thenBlock, elseBlock);
} else {
builder.CreateCondBr(condition, thenBlock, mergeBlock);
}
builder.SetInsertPoint(thenBlock);
createScope();
node.thenBlock->accept(this);
popScope();
thenBlock = builder.GetInsertBlock();
if (thenBlock->getTerminator() == nullptr) {
builder.CreateBr(mergeBlock);
}
if (node.elseBlock) {
function->getBasicBlockList().push_back(elseBlock);
builder.SetInsertPoint(elseBlock);
createScope();
node.elseBlock->accept(this);
popScope();
builder.CreateBr(mergeBlock);
}
function->getBasicBlockList().push_back(mergeBlock);
builder.SetInsertPoint(mergeBlock);
return nullptr;
}
static bool decode(
pattern_type & pattern, in_type & istr,
::libmaus::parallel::SynchronousCounter<uint64_t> & nextid
)
{
try
{
// decode pattern length
uint32_t const patlen = decodeUTF8(istr);
// check for terminator
if ( patlen == getTerminator() )
{
return false;
}
else
{
// decode flags
uint32_t const flags = decodeUTF8(istr);
// resize pattern
try
{
pattern.spattern.resize(patlen);
}
catch(std::exception const & ex)
{
std::cerr << "exception while resizing pattern to length " << patlen << " in CompactFastDecoderBase::decode(): " << ex.what() << std::endl;
throw;
}
// pattern has indeterminate bases
if ( flags & 1 )
{
uint64_t const full = (patlen >> 1);
uint64_t const brok = patlen&1;
std::string::iterator ita = pattern.spattern.begin();
for ( uint64_t i = 0; i < full; ++i )
{
int v = istr.get();
if ( v < 0 )
{
::libmaus::exception::LibMausException se;
se.getStream() << "EOF in getNextPatternUnlocked()";
se.finish();
throw se;
}
*(ita++) = v & 0xF; v >>= 4;
*(ita++) = v & 0xF; v >>= 4;
}
if ( brok )
{
int v = istr.get();
if ( v < 0 )
{
::libmaus::exception::LibMausException se;
se.getStream() << "EOF in getNextPatternUnlocked()";
se.finish();
throw se;
}
*(ita++) = v & 0xF; v >>= 4;
}
}
// pattern has determinate bases only
else
{
// full bytes
uint64_t const full = (patlen >> 2);
// fractional rest
uint64_t const brok = patlen&3;
std::string::iterator ita = pattern.spattern.begin();
// decode full bytes (four symbols each)
for ( uint64_t i = 0; i < full; ++i )
{
int v = istr.get();
if ( v < 0 )
{
::libmaus::exception::LibMausException se;
se.getStream() << "EOF in getNextPatternUnlocked()";
se.finish();
throw se;
}
*(ita++) = v & 0x3; v >>= 2;
*(ita++) = v & 0x3; v >>= 2;
*(ita++) = v & 0x3; v >>= 2;
*(ita++) = v & 0x3; v >>= 2;
}
// decode fractional
if ( brok == 3 )
{
int v = istr.get();
if ( v < 0 )
{
::libmaus::exception::LibMausException se;
se.getStream() << "EOF in getNextPatternUnlocked()";
se.finish();
throw se;
}
*(ita++) = v & 0x3; v >>= 2;
*(ita++) = v & 0x3; v >>= 2;
*(ita++) = v & 0x3; v >>= 2;
}
else if ( brok == 2 )
