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; }