void Synthesizer::encodeSecondOperand(const Operand &secondOperand)
{
if(secondType != Operand::OPERAND_UNKNOWN)
{
throw INTERNAL_ERROR; // Instruction source already set
}
secondType = secondOperand.type;
if(Operand::isReg(secondType))
{
secondReg = secondOperand.reg;
}
else if(Operand::isMem(secondType))
{
encodeBase(secondOperand);
encodeIndex(secondOperand);
setScale(secondOperand.scale);
setDisplacement(secondOperand.displacement);
referenceLabel(secondOperand.reference);
}
else if(Operand::isImm(secondType))
{
encodeImmediate(secondOperand.value);
referenceLabel(secondOperand.reference);
}
else if(!Operand::isVoid(secondType))
{
throw INTERNAL_ERROR;
}
}
void EncodeBuffer::encodeCachedValue(unsigned int value,
unsigned int numBits,
IntCache & cache,
unsigned int blockSize)
{
(void)blockSize;
unsigned int newBlockSize = cache.getBlockSize(numBits);
unsigned int index;
unsigned int sameDiff;
// The index is encoded as the number of leading zeros before a 1
// bit. The index value 2 is a magic escape code.
DBG("encodeIntCache.\n");
if (cache.lookup(value, index, PARTIAL_INT_MASK[numBits], sameDiff))
{
encodeIndex(index);
}
else
{
encodeEscapeIndex();
if (sameDiff)
encodeDirect(1, 1);
else
{
encodeDirect(0, 1);
encodeValue(value, numBits, newBlockSize);
}
}
}
void Synthesizer::encodeFirstOperand(const Operand &firstOperand)
{
if(firstType != Operand::OPERAND_UNKNOWN)
{
throw INTERNAL_ERROR; // Instruction destination already set
}
firstType = firstOperand.type;
if(Operand::isReg(firstType))
{
firstReg = firstOperand.reg;
}
else if(Operand::isMem(firstType))
{
encodeBase(firstOperand);
encodeIndex(firstOperand);
setScale(firstOperand.scale);
setDisplacement(firstOperand.displacement);
referenceLabel(firstOperand.reference);
}
else if(Operand::isImm(firstType))
{
encodeImmediate(firstOperand.value);
referenceLabel(firstOperand.reference);
}
else if(!Operand::isVoid(firstType))
{
throw INTERNAL_ERROR;
}
}
void Synthesizer::encodeBase(const Operand &base)
{
if(baseReg != Encoding::REG_UNKNOWN)
{
// Base already set, use as index with scale = 1
encodeIndex(base);
setScale(1);
return;
}
baseReg = base.baseReg;
}
void EncodeBuffer::encodeCachedValue(unsigned char value,
unsigned int numBits,
CharCache & cache,
unsigned int blockSize)
{
unsigned int index;
DBG("encodeCharCache.\n");
if (cache.lookup(value, index))
{
encodeIndex(index);
}
else
{
encodeEscapeIndex();
encodeValue(value, numBits, blockSize);
}
}
void EncodeBuffer::encodeCachedValue(unsigned int value,
unsigned int numBits,
PixelCache & cache,
HuffmanCoder & escapeCoder0,
HuffmanCoder & escapeCoder1)
{
unsigned int index;
DBG("encodePixelCache.\n");
if (cache.lookup(value, index))
{
encodeIndex(index);
}
else
{
encodeEscapeIndex();
// To transmit the value, use run-length coding with the static
// Huffman code implemented by the supplied "escapeCoder" object
//X encodeValue(value, numBits, numBits);
unsigned int srcMask = 0x1;
unsigned int pixelValue = ((value & srcMask) ? 1 : 0);
encodeDirect(pixelValue, 1);
for (unsigned int x = 0; x < numBits;)
{
unsigned int runStart = x;
if (pixelValue)
{
while (x < numBits)
{
if (!(value & srcMask))
break;
srcMask <<= 1;
x++;
}
}
else
{
while (x < numBits)
{
if (value & srcMask)
break;
srcMask <<= 1;
x++;
}
}
unsigned int runLength = x - runStart;
if (pixelValue)
{
escapeCoder1.encode(runLength - 1, *this);
pixelValue = 0;
}
else
{
escapeCoder0.encode(runLength - 1, *this);
pixelValue = 1;
}
}
}
}
void EncodeBuffer::encodeEscapeIndex(void)
{
DBG("EncodeBuffer::encodeEscapeIndex\n");
// Write the magic index 2, which is encoded as '001'.
encodeIndex(2, 1);
}
ge_id_t GeneticEventManager::encode_event( const GeneticEvent * ge ) {
ge_id_t id;
if( ge->getType() == SUBSTITUTION ) {
switch( ge->length() ) {
case 0:
assert( false );
break;
case 1:
id = encodeImmediate( ge, efSUBSTITUTION1 );
delete ge;
break;
case 2:
id = encodeImmediate( ge, efSUBSTITUTION2 );
delete ge;
break;
case 3:
id = encodeImmediate( ge, efSUBSTITUTION3 );
delete ge;
break;
case 4:
id = encodeImmediate( ge, efSUBSTITUTION4 );
delete ge;
break;
default:
index_t idx = m_events->size();
m_events->push_back( ge );
id = encodeIndex( idx );
break;
}
} else if( ge->getType() == DELETION ) {
id = encodeDeletion( ge->getStart(), ge->getEnd() );
delete ge;
} else if( ge->getType() == INSERTION ) {
switch( ge->length() ) {
case 0:
assert( false );
break;
case 1:
id = encodeImmediate( ge, efINSERT1 );
delete ge;
break;
case 2:
id = encodeImmediate( ge, efINSERT2 );
delete ge;
break;
case 3:
id = encodeImmediate( ge, efINSERT3 );
delete ge;
break;
case 4:
id = encodeImmediate( ge, efINSERT4 );
delete ge;
break;
default:
index_t idx = m_events->size();
m_events->push_back( ge );
id = encodeIndex( idx );
break;
}
} else {
index_t idx = m_events->size();
m_events->push_back( ge );
id = encodeIndex( idx );
}
return id;
}
