internal CompressedBitmapBuilder(CompressedWord[] words, int size, BitRange range)
{
Contract.Requires(words != null && size >= 0);
m_words = words;
m_size = size;
m_lowest = range.Lowest;
m_highest = range.Highest;
}
public override RegisterStorage GetRegister(StorageDomain domain, BitRange range)
{
if (domain == Registers.fr0.Domain)
{
// Special case the floating point numbers.
if (range.Extent == 32)
{
return(Registers.fpregs[range.Lsb / 32]);
}
if (range.Extent == 64)
{
return(Registers.dfpregs[range.Lsb / 64]);
}
throw new NotImplementedException("GetRegister: FP registers not done yet.");
}
return(Registers.RegistersByDomain.TryGetValue(domain, out var reg)
? reg
: null);
}
public void PIC18arch_GetSubregisterTests()
{
var arch = GetArch(PIC18EggName);
PICMemoryDescriptor.ExecMode = PICExecMode.Traditional;
var lowByte = new BitRange(0, 8);
var highByte = new BitRange(8, 16);
var word = new BitRange(0, 16);
Assert.AreSame(PIC18Registers.FSR0L, arch.GetRegister(PIC18Registers.FSR0.Domain, lowByte));
Assert.AreSame(PIC18Registers.FSR0H, arch.GetRegister(PIC18Registers.FSR0.Domain, highByte));
Assert.AreSame(PIC18Registers.FSR0, arch.GetRegister(PIC18Registers.FSR0.Domain, word));
PICMemoryDescriptor.ExecMode = PICExecMode.Extended;
Assert.AreSame(PIC18Registers.FSR1L, arch.GetRegister(PIC18Registers.FSR1.Domain, lowByte));
Assert.AreSame(PIC18Registers.FSR1H, arch.GetRegister(PIC18Registers.FSR1.Domain, highByte));
Assert.AreSame(PIC18Registers.FSR2L, arch.GetRegister(PICRegisters.GetRegister("FSR2").Domain, lowByte));
Assert.AreSame(PIC18Registers.FSR2H, arch.GetRegister(PICRegisters.GetRegister("FSR2").Domain, highByte));
Assert.AreSame(PIC18Registers.FSR2, arch.GetRegister(PICRegisters.GetRegister("FSR2").Domain, word));
}
public override RegisterStorage GetRegister(StorageDomain dom, BitRange range)
{
var i = (int)dom;
if (0 <= i && i < Registers.SubRegisters.Length)
{
var subregs = Registers.SubRegisters[i];
var reg = subregs[0];
for (int j = 0; j < subregs.Length; ++j)
{
var subreg = subregs[j];
if ((short)subreg.BitSize < range.Msb)
{
break;
}
reg = subreg;
}
return(reg);
}
return(null);
}
public override RegisterStorage?GetRegister(StorageDomain domain, BitRange range)
{
uint iReg = (uint)domain;
if (iReg < Registers.WordRegs.Length)
{
if (range.Extent != 8)
{
return(Registers.WordRegs[iReg]);
}
iReg *= 2;
if (range.Lsb == 8)
{
++iReg;
}
if (iReg < Registers.ByteRegs.Length)
{
return(Registers.ByteRegs[iReg]);
}
}
return(null);
}
public BitPatternPieceOperation(BitPattern parent, Token[] toks, ref int curIdx)
{
Parent = parent;
Token tok;
tok = toks[curIdx];
if (tok.Type == TokenType.Identifier)
{
OpType = OperationType.Arg;
if (!int.TryParse(tok.Value.Substring(1), out ArgIdx))
throw new Exception("Unknown argument '" + tok.Value + "'!");
curIdx++;
tok = toks[curIdx];
if (tok.Type != TokenType.LSqBracket)
throw new Exception("Expected the opening square bracket for the bit pattern operation selector!");
curIdx++;
Range = new BitRange(toks, ref curIdx);
parent.RequestArg(ArgIdx, Range.EndIdx);
}
else if (tok.Type == TokenType.Number)
{
OpType = OperationType.Literal;
Literal = tok.NumberValue.Value;
Number n = tok.NumberValue;
curIdx++;
tok = toks[curIdx];
if (n.Format == NumberFormat.Binary)
{
if (tok.Type != TokenType.LSqBracket)
{
Range = new BitRange(0, n.LiteralLength - 1);
}
else
{
curIdx++;
Range = new BitRange(toks, ref curIdx);
}
}
else if (tok.Type != TokenType.LSqBracket)
{
Range = new BitRange(0, Utils.GetHighestBitIndexSet(Literal));
}
else
{
curIdx++;
Range = new BitRange(toks, ref curIdx);
}
}
else if (tok.Type == TokenType.LParen)
{
curIdx++;
OpType = OperationType.BinaryOp;
tok = toks[curIdx];
switch(tok.Type)
{
case TokenType.Star:
BinaryOp = CodeBinaryOperatorType.Multiply;
break;
case TokenType.Plus:
BinaryOp = CodeBinaryOperatorType.Add;
break;
default:
throw new Exception("Unknown math operation to perform!");
}
curIdx++;
LHand = new BitPatternPieceOperation(parent, toks, ref curIdx);
RHand = new BitPatternPieceOperation(parent, toks, ref curIdx);
tok = toks[curIdx];
if (tok.Type != TokenType.RParen)
throw new Exception("Expected a closing parenthesis!");
curIdx++;
tok = toks[curIdx];
if (tok.Type != TokenType.LSqBracket)
{
Range = new BitRange(0, 32);
}
else
{
curIdx++;
Range = new BitRange(toks, ref curIdx);
}
}
else if (tok.Type == TokenType.Cash)
{
InvokedPatternArgMapping = new List<BitPatternInvokeArgumentEntry>();
OpType = OperationType.PatternInvoke;
curIdx++;
tok = toks[curIdx];
if (tok.Type != TokenType.Identifier)
throw new Exception("Expected an identifier for the bit pattern to invoke!");
InvokedPattern = BitPatternRegistry.GetPattern(tok.Value);
curIdx++;
tok = toks[curIdx];
if (tok.Type != TokenType.LSqBracket)
throw new Exception("Expected a left square bracket for the arguments to the bit operation!");
curIdx++;
tok = toks[curIdx];
bool expectsArg = true;
bool first = true;
while(tok.Type != TokenType.RSqBracket)
{
if (!expectsArg)
throw new Exception("Expected a closing square bracket for the arguments to the bit operation!");
InvokedPatternArgMapping.Add(new BitPatternInvokeArgumentEntry(parent, toks, ref curIdx));
tok = toks[curIdx];
if (tok.Type == TokenType.Comma)
{
curIdx++;
tok = toks[curIdx];
}
else
{
expectsArg = false;
}
first = false;
}
if (expectsArg && !first)
throw new Exception("Expected another argument!");
curIdx++;
}
else
{
throw new Exception("Unsupported bit pattern operation!");
}
}
public override RegisterStorage?GetRegister(StorageDomain domain, BitRange range)
{
return(Registers.ByDomain.TryGetValue(domain, out var reg)
? reg
: null);
}
public override RegisterStorage GetRegister(StorageDomain domain, BitRange range)
{
return(Registers.GetRegister(domain));
}
public override RegisterStorage GetRegister(StorageDomain domain, BitRange range)
{
return(Registers.GpRegisters[(int)domain]);
}
/// <summary> /// Gets a register given its index number. /// </summary> /// <param name="i">Zero-based index of the register.</param> /// <returns> /// The register instance or null. /// </returns> public override RegisterStorage GetRegister(StorageDomain domain, BitRange range) => PICRegisters.PeekRegisterByIdx(domain - StorageDomain.Register);
public override RegisterStorage GetRegister(StorageDomain domain, BitRange range)
{
return(Registers.RegistersByDomain[domain]);
}
public RegisterStorage GetSubregister(RegisterStorage rIdx, BitRange range)
{
return(Architecture.GetRegister(rIdx.Domain, range));
}
public void Bitr_Bitmask_64bit()
{
var a = new BitRange(0, 64);
Assert.AreEqual(~0ul, a.BitMask());
}
public void Bitr_Bitmask_32bit()
{
var a = new BitRange(0, 32);
Assert.AreEqual(0xFFFFFFFF, a.BitMask());
}
public void Bitr_Bitmask()
{
var a = new BitRange(8, 16);
Assert.AreEqual(0xFF00, a.BitMask());
}
internal static CompressedWord[] DecodeWords(Slice data, int size, BitRange bounds)
{
Contract.Requires(size >= 0 && data.Count >= 4 && (data.Count & 3) == 0);
int capacity = SliceHelpers.NextPowerOfTwo(size);
if (capacity < 0) capacity = size;
var words = new CompressedWord[capacity];
var end = data.Offset + data.Count;
for (int i = 0, p = data.Offset + 4; p < end; i++, p += 4)
{
words[i] = new CompressedWord(data.ReadUInt32(p, 4));
}
return words;
}
public override RegisterStorage?GetRegister(StorageDomain domain, BitRange range)
{
return(Registers.GetRegister(domain, range.BitMask()));
}
public RegisterTransformer(Identifier id, Statement stm, SsaTransform outer)
: base(id, stm, outer)
{
this.liveBits = id.Storage.GetBitRange();
}
public override SsaIdentifier ReadBlockLocalVariable(SsaBlockState bs)
{
DebugEx.Verbose(trace, " ReadBlockLocalVariable: ({0}, {1}, ({2})", bs.Block.Name, id, this.liveBits);
if (!bs.currentDef.TryGetValue(id.Storage.Domain, out var alias))
{
return(null);
}
// Identifier id is defined locally in this block.
// Has an exact alias already been calculated?
if (alias.ExactAliases.TryGetValue(id.Storage, out var sid))
{
DebugEx.Verbose(trace, " found alias ({0}, {1})", bs.Block.Name, sid.Identifier.Name);
return(sid);
}
// At least some of the bits of 'id' are defined locally in this
// block. Walk across the bits of 'id', collecting all parts
// defined into a sequence.
int offsetLo = this.liveBits.Lsb;
int offsetHi = this.liveBits.Msb;
var sids = new List <(SsaIdentifier, BitRange)>();
while (offsetLo < offsetHi)
{
var useRange = new BitRange(offsetLo, offsetHi);
var(sidElem, usedRange, defRange) = FindIntersectingRegister(alias.Definitions, useRange);
if (sidElem == null || offsetLo < usedRange.Lsb)
{
// Found a gap in the register that wasn't defined in
// this basic block. Seek backwards
var bitrangeR = sidElem == null
? useRange
: new BitRange(offsetLo, usedRange.Lsb);
var idR = MakeTmpIdentifier(sidElem, bitrangeR);
var rx = new RegisterTransformer(idR, stm, this.outer)
{
liveBits = bitrangeR
};
var sidR = rx.ReadVariableRecursive(bs);
sids.Add((sidR, bitrangeR));
offsetLo = bitrangeR.Msb;
}
if (sidElem != null)
{
sids.Add((sidElem, defRange));
offsetLo = usedRange.Msb;
}
}
if (sids.Count == 1)
{
var sidSlice = MakeSlice(sids[0].Item1, sids[0].Item2, this.id);
alias.ExactAliases[this.id.Storage] = sidSlice;
return(sidSlice);
}
else
{
sids.Reverse(); // Order sids in big-endian order
var elems = new List <Expression>();
foreach (var(sidElem, bitrange) in sids)
{
var idSlice = MakeTmpIdentifier(sidElem, bitrange);
var sidSlice = MakeSlice(sidElem, bitrange, idSlice);
alias.ExactAliases[sidSlice.OriginalIdentifier.Storage] = sidSlice;
elems.Add(sidSlice.Identifier);
}
var seq = outer.m.Seq(elems.ToArray());
var assSeq = new AliasAssignment(id, seq);
var sidTo = InsertBeforeStatement(bs.Block, this.stm, assSeq);
seq.Accept(new InstructionUseAdder(sidTo.DefStatement, ssaIds));
alias.ExactAliases[this.id.Storage] = sidTo;
return(sidTo);
}
}
public override RegisterStorage GetRegister(StorageDomain domain, BitRange range)
{
return(GetRegister(domain - StorageDomain.Register));
}
public CallBinding(Storage stg, Expression exp)
{
this.Storage = stg;
this.Expression = exp;
this.BitRange = new BitRange(0, exp.DataType.BitSize);
}
public override RegisterStorage?GetRegister(StorageDomain domain, BitRange range)
{
return(GetSubregister(domain, range));
}
/// <summary>
/// Gets a register given its index number.
/// </summary>
/// <param name="i">Zero-based index of the register.</param>
/// <returns>
/// The register instance or null.
/// </returns>
public override RegisterStorage GetRegister(StorageDomain domain, BitRange range)
=> PICRegisters.GetSubregister(
PICRegisters.PeekRegisterByIdx(domain - StorageDomain.Register),
range.Lsb,
range.Extent) !;
public RegisterStorage GetSubregister(RegisterStorage reg, BitRange range)
{
return(arch.GetRegister(reg.Domain, range) !);
}
public override RegisterStorage GetRegister(StorageDomain domain, BitRange range)
{
return(GetSubregisterUsingMask(domain, range.BitMask()));
}
public override RegisterStorage GetRegister(StorageDomain domain, BitRange range)
{
int i = domain - StorageDomain.Register;
return(GetRegister(i));
}
public override RegisterStorage GetRegister(StorageDomain domain, BitRange range)
{
return(allRegs[domain - StorageDomain.Register]);
}
public override RegisterStorage?GetRegister(StorageDomain domain, BitRange range)
{
throw new NotImplementedException();
}
/// <summary>Flush the state and update the header</summary>
/// <param name="padding">Padding bits that were added to the last written word</param>
/// <returns>Slice contained the finished compressed bitmap</returns>
/// <remarks>You cannot write any more words after Packing, until <see cref="Reset"/> is called.</remarks>
public void Pack()
{
if (m_packed) ThrowAlreadyPacked();
// flush any pending word
Flush();
if (m_words == 0)
{ // empty!
m_bounds = BitRange.Empty;
// there will be no header
m_writer.Position = m_head;
}
else
{
// we need to find the lowest and highest bits
m_bounds = CompressedBitmap.ComputeBounds(m_writer.ToSlice(), m_words);
// update the header
int p;
m_writer.Rewind(out p, m_head);
//the last word is either a literal, or a 1-bit filler
m_writer.WriteFixed32(CompressedWord.MakeHeader(m_bounds.Highest));
m_writer.Position = p;
}
m_packed = true;
}
