void RemoveValBit(FrameId frame, BlockMemory *mcfg,
const GuardBitVector &input, GuardBitVector *output)
{
for (size_t iind = 0; iind < input.Size(); iind++) {
const GuardBit &igb = input[iind];
RemoveFrameMapper mapper(frame);
Bit *nbit = igb.bit->DoMap(&mapper);
GuardBitVector remove_res;
mcfg->TranslateBit(TRK_RemoveVal, 0, nbit, &remove_res);
nbit->DecRef();
for (size_t rind = 0; rind < remove_res.Size(); rind++) {
const GuardBit &rgb = remove_res[rind];
rgb.IncRef();
igb.guard->IncRef();
Bit *new_guard = Bit::MakeAnd(igb.guard, rgb.guard);
output->PushBack(GuardBit(rgb.bit, new_guard));
}
}
output->SortCombine();
}
int dfs(int curr, vb& path, int len, int inv, Bit& bit) const
{
path[curr] = true;
++len;
bit.add(V[curr], 1);
inv += bit.rangeCount(V[curr] + 1, 1000);
int ret = INT_MAX;
do {
if (K == len) {
ret = inv;
break;
}
if (K < len)
break;
for (int i = 0; i < G[curr].size(); ++i) {
int node = G[curr][i];
if (!path[node]) {
ret = min(ret, dfs(node, path, len, inv, bit));
}
}
} while (false);
path[curr] = false;
bit.add(V[curr], -1);
return ret;
}
int solve()
{
sort(sticks, sticks + N);
int hi = sticks[N - 1];
int ans = 0;
tree.init(sticks[N - 1]);
for (int i = N - 4; i >= 2; --i) {
int a = i + 1;
for (int b = a + 1; b < N; ++b)
for (int c = b + 1; c < N; ++c) {
int v = max(1, sticks[c] - (sticks[a] + sticks[b]));
tree.add(v, 1);
}
for (int j = i - 1; j >= 1; --j)
for (int k = j - 1; k >= 0; --k) {
int v = min(hi, sticks[i] + sticks[j] + sticks[k]);
ans += tree.query(v - 1);
}
}
return ans;
}
int main ()
{
bit = Bit (20);
bit.Set (1, 10);
printf ("%d\n", bit.Sum (15));
return 0;
}
int HuffmanDecoder::decode(IOReader& reader, IOWriter& writer, BitCode codes[], size_t codeCnt, size_t excessBit) {
const size_t fileSize = reader.size() - sizeof(HuffmanFileHeader);
size_t firstCode = 0;
while (firstCode < codeCnt && codes[firstCode].bit.len == 0)
++firstCode;
if (firstCode >= codeCnt)
return 0;
const size_t minCodeLength = codes[firstCode].bit.len;
const __int64 availableBits = excessBit ? ((fileSize -1 ) * 8 + excessBit) : fileSize * 8;
__int64 consumeBits = 0;
while(consumeBits < availableBits) {
size_t codeLength = minCodeLength;
Bit data = reader.readBits(codeLength);
if (data.len != codeLength)
return 1;
consumeBits += data.len;
bool find = false;
for (size_t i = firstCode; i< codeCnt; ++i ) {
const Bit& bit = codes[i].bit;
if (bit.len > codeLength) {
Bit appendBits = reader.readBits( bit.len - codeLength);
if (appendBits.len != bit.len - codeLength)
return 1;
consumeBits += appendBits.len;
data.add(appendBits);
codeLength = bit.len;
}
if (bit.bits == data.bits) {
writer.write(&(codes[i].value), 1);
find = true;
break;
}
}
if (!find )
return 2;
};
return 0;
}
Bit PermutationManager::InversePermutation(Bit bit, IPermutationTable* table) {
int sz = bit.Size();
int n = table->Size();
Bit res(0, sz);
for (int i = 0; i < n; i++) {
if (bit[i]) res.Set(table->Get(i) - 1);
}
return res;
}
/**
* Función para modificar los bits de un arreglo de caracteres de acuerdo a los parámetros recibidos
* @param salida Es un arreglo de caracteres al cual se le van a modificar los bits
* @param salidaLength El tamaño en bits del arreglo
* @param pointer La posición a partir de la cual se comenzar a modificar los
* @param c El caracter a codificar
* @param frecuencias El arreglo de las frecuencias
* @param length El tamaño del arreglo de frecuencias
*/
int Codificacion::escribeBits(char * salida, int salidaLength, long pointer, char c, Frecuencia * frecuencias, int length){
int bitsescritos = 0;
int indiceFrecuencia = buscaFrecuencia(frecuencias, 0, length, c);
Frecuencia f = frecuencias[indiceFrecuencia];
Bit * bits = new Bit();
if (indiceFrecuencia >= 0){
for (bitsescritos = 0; f.codigo[bitsescritos] != '\0'; bitsescritos++)
{
if (f.codigo[bitsescritos] == '1')
{
bits->pon1(salida, pointer + bitsescritos);
}
else if (f.codigo[bitsescritos] == '0')
{
bits->pon0(salida, pointer + bitsescritos);
}
}
}
return bitsescritos;
}
int main(){
// freopen("input.txt", "r", stdin);
Node lis[SZ];
int n;
int test, val, pos, tc = 1;
scanf("%d", &test);
while( test-- ){
scanf("%d", &n);
for(int i = 1; i <= n; i++){
scanf("%d", &val);
lis[i] = Node(val, i);
}
sort(lis+1, lis+n+1);
Bit bt = Bit(n);
for(int idx = 1; idx <= n; idx++){
pos = lis[idx].pos;
bt.add(pos, 1 + bt.query(pos-1));
}
printf("Case %d: %lld\n", tc++, bt.query(n));
}
return 0;
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d", &N, &M);
bit.init(N + M);
for (int i = 1; i <= N; i++) {
bit.add(i, 1);
no[i] = N + 1 - i;
}
for (int i = 1; i <= M; i++) {
scanf("%d", &A[i]);
printf("%d%c", N - bit.sum(no[A[i]]), i < M ? ' ' : '\n');
bit.add(no[A[i]], -1);
no[A[i]] = N + i;
bit.add(no[A[i]], 1);
}
}
return 0;
}
int main()
{
int T;
scanf("%d", &T);
int ncase = 0;
while (T--) {
scanf("%d", &N);
tree.init(N);
for (int i = 1; i <= N; ++i) {
int x;
scanf("%d", &x);
tree.add(i, x);
}
printf("Case %d:\n", ++ncase);
scanf("%d", &M);
while (M--) {
int cmd;
scanf("%d", &cmd);
if (cmd == 1) {
int x, y;
scanf("%d%d", &x, &y);
printf("%d\n", tree.query(x, y));
}
else if (cmd == 2) {
int x, y, p;
scanf("%d%d%d", &x, &y, &p);
tree.add(x, -p);
tree.add(y, p);
}
}
}
return 0;
}
QVector<Bit> AVRStudioXMLParser::GetBits(QDomNode node)
{
QVector<Bit> bits(0);
while(!node.isNull())
{
QDomNamedNodeMap attributes = node.attributes();
Bit bit;
for(int i = 0; i < attributes.size(); i++)
{
QDomNode attribute = attributes.item(i);
if(bit.GetMappingMap()[attribute.nodeName()])
*bit.GetMappingMap()[attribute.nodeName()] = attribute.nodeValue();
}
bit.SetValues(GetValues(node.childNodes()));
bits.append(bit);
node = node.nextSibling();
}
return bits;
}
void GetImplySufficient(CheckerFrame *frame, Vector<Bit*> *imply_list)
{
// only getting implications for loops for now.
if (frame->Kind() != B_Loop)
return;
// look for assumed bits of the form 'A || B'.
// then check if either !A or !B is a sufficient condition
// (this will force the other half of the implication to hold).
for (size_t bind = 0; bind < frame->m_assumed_bits.Size(); bind++) {
Bit *bit = frame->m_assumed_bits[bind];
if (bit->Kind() == BIT_Or) {
for (size_t oind = 0; oind < bit->GetOperandCount(); oind++) {
Bit *op = bit->GetOperand(oind);
Bit *nop = Bit::MakeNot(op);
if (!imply_list->Contains(nop))
imply_list->PushBack(nop);
}
}
}
}
bool CheckSingleHeapWrite(CheckerState *state, CheckerFrame *frame,
CheckerFrame *heap_frame, WhereInvariant *invariant,
const HeapWriteInfo &write)
{
Assert(invariant);
if (checker_verbose.IsSpecified())
logout << "CHECK: " << frame
<< ": Checking single heap write: " << write.mcfg->GetId()
<< ": " << write.lval << endl;
if (frame->Memory()->GetId()->Kind() == B_Initializer) {
// rule out cases where another function executed before a static
// initializer. TODO: this case can occur in C++ constructors and the
// functions they call, should revisit this behavior.
if (write.mcfg->GetId()->Kind() != B_Initializer) {
if (checker_verbose.IsSpecified())
logout << "CHECK: " << frame
<< ": Write is not in a static initializer" << endl;
return false;
}
}
CheckerFrame *write_frame = state->MakeFrame(write.mcfg->GetId());
Assert(write_frame && write_frame->Memory() == write.mcfg);
PPoint exit_point = write.mcfg->GetCFG()->GetExitPoint();
write_frame->AssertPointGuard(exit_point, true);
// assert the lvalue is actually updated within this frame. these bits
// are never explicitly popped, they get dropped when the frame is deleted.
for (size_t ind = 0; ind < write.exclude.Size(); ind++) {
Bit *bit = write.exclude[ind];
bit->IncRef();
Bit *not_bit = Bit::MakeNot(bit);
write_frame->PushAssumedBit(not_bit);
not_bit->DecRef();
}
// connect the heap read and write frames.
write_frame->ConnectHeapRead(heap_frame);
// for type invariants, try to reconstruct the CSU exp for the write frame.
Exp *write_csu = NULL;
Exp *base_csu = NULL;
if (invariant->GetCSU()) {
write_csu = invariant->GetWriteCSU(write.lval);
if (write_csu == NULL) {
CheckerPropagate propagate(write_frame, exit_point, false);
state->m_stack.PushBack(&propagate);
state->SetReport(RK_UnknownCSU);
return true;
}
// OK if we couldn't figure out the point-relative CSU, will just be
// a more confusing UI message.
base_csu = invariant->GetWriteCSU(write.base_lval);
}
// get the safe bits for the write frame.
Bit *write_safe_bit;
GuardBitVector write_safe_list;
invariant->GetHeapBits(write_frame, write_csu, base_csu,
&write_safe_bit, &write_safe_list);
if (CheckFrameList(state, write_frame, exit_point, true, true,
write_safe_bit, write_safe_list)) {
write_safe_bit->DecRef();
return true;
}
write_safe_bit->DecRef();
write_frame->DisconnectHeapRead(heap_frame);
state->DeleteFrame(write_frame);
return false;
}
/*
* Return true if a flag is set, false otherwise.
*/
void Modifier::set(Bit flag)
{ flag.set(flags_); }
/*
* Return true if a flag is set, false otherwise.
*/
bool Modifier::isSet(Bit flag) const
{ return flag.isSet(flags_); }
void BlockSummary::GetAssumedBits(BlockMemory *mcfg, PPoint end_point,
Vector<AssumeInfo> *assume_list)
{
BlockId *id = mcfg->GetId();
BlockCFG *cfg = mcfg->GetCFG();
BlockSummary *sum = GetBlockSummary(id);
const Vector<Bit*> *assumes = sum->GetAssumes();
size_t assume_count = VectorSize<Bit*>(assumes);
// pull in assumptions from the summary for mcfg. in some cases these
// assumptions won't be useful, e.g. describing the state at exit
// for functions. for now we're just adding all of them though. TODO: fix.
for (size_t ind = 0; ind < assume_count; ind++) {
Bit *bit = assumes->At(ind);
bit->IncRef(assume_list);
AssumeInfo info;
info.bit = bit;
assume_list->PushBack(info);
}
sum->DecRef();
Vector<BlockCFG*> *annot_list = BodyAnnotCache.Lookup(id->Function());
// add assumes at function entry for any preconditions.
if (id->Kind() == B_Function) {
for (size_t ind = 0; annot_list && ind < annot_list->Size(); ind++) {
BlockCFG *annot_cfg = annot_list->At(ind);
if (annot_cfg->GetAnnotationKind() != AK_Precondition &&
annot_cfg->GetAnnotationKind() != AK_PreconditionAssume)
continue;
Bit *bit = BlockMemory::GetAnnotationBit(annot_cfg);
if (!bit) continue;
annot_cfg->IncRef(assume_list);
bit->IncRef(assume_list);
AssumeInfo info;
info.annot = annot_cfg;
info.bit = bit;
assume_list->PushBack(info);
}
}
// add assumptions from points within the block.
for (size_t pind = 0; pind < cfg->GetPointAnnotationCount(); pind++) {
PointAnnotation pann = cfg->GetPointAnnotation(pind);
if (end_point && pann.point >= end_point)
continue;
BlockCFG *annot_cfg = GetAnnotationCFG(pann.annot);
if (!annot_cfg) continue;
Assert(annot_cfg->GetAnnotationKind() != AK_AssertRuntime);
if (Bit *bit = BlockMemory::GetAnnotationBit(annot_cfg)) {
// get the annotation bit in terms of block entry.
Bit *point_bit = NULL;
mcfg->TranslateBit(TRK_Point, pann.point, bit, &point_bit);
point_bit->MoveRef(&point_bit, assume_list);
annot_cfg->IncRef(assume_list);
AssumeInfo info;
info.annot = annot_cfg;
info.point = pann.point;
info.bit = point_bit;
assume_list->PushBack(info);
}
annot_cfg->DecRef();
}
// add assumptions from annotation edges within the block, invariants
// on values accessed by the block, and from the summaries of any callees.
for (size_t eind = 0; eind < cfg->GetEdgeCount(); eind++) {
PEdge *edge = cfg->GetEdge(eind);
PPoint point = edge->GetSource();
if (end_point && point >= end_point)
continue;
InvariantAssumeVisitor visitor(mcfg, point, assume_list);
edge->DoVisit(&visitor);
if (PEdgeAnnotation *nedge = edge->IfAnnotation()) {
// add an assumption for this annotation.
BlockCFG *annot_cfg = GetAnnotationCFG(nedge->GetAnnotationId());
if (!annot_cfg) continue;
Bit *bit = BlockMemory::GetAnnotationBit(annot_cfg);
// don't incorporate AssertRuntimes, these are not assumed.
if (bit && annot_cfg->GetAnnotationKind() != AK_AssertRuntime) {
// get the annotation bit in terms of block entry.
Bit *point_bit = NULL;
mcfg->TranslateBit(TRK_Point, point, bit, &point_bit);
point_bit->MoveRef(&point_bit, assume_list);
annot_cfg->IncRef(assume_list);
AssumeInfo info;
info.annot = annot_cfg;
info.point = point;
info.bit = point_bit;
assume_list->PushBack(info);
}
annot_cfg->DecRef();
}
if (BlockId *callee = edge->GetDirectCallee()) {
GetCallAssumedBits(mcfg, edge, callee, false, assume_list);
callee->DecRef();
}
else if (edge->IsCall()) {
// add conditional assumes for the indirect targets of the call.
// this is most useful for baked information and annotations, where
// we sometimes need to attach information at indirect calls.
CallEdgeSet *callees = CalleeCache.Lookup(id->BaseVar());
size_t old_count = assume_list->Size();
if (callees) {
for (size_t cind = 0; cind < callees->GetEdgeCount(); cind++) {
const CallEdge &cedge = callees->GetEdge(cind);
if (cedge.where.id == id && cedge.where.point == point) {
cedge.callee->IncRef();
BlockId *callee = BlockId::Make(B_Function, cedge.callee);
GetCallAssumedBits(mcfg, edge, callee, true, assume_list);
callee->DecRef();
}
}
}
if (assume_list->Size() != old_count) {
// we managed to do something at this indirect call site.
// add another assumption restricting the possible callees to
// only those identified by our callgraph.
GuardExpVector receiver_list;
mcfg->TranslateReceiver(point, &receiver_list);
for (size_t rind = 0; rind < receiver_list.Size(); rind++) {
const GuardExp &gs = receiver_list[rind];
gs.guard->IncRef();
// make a bit: !when || rcv == callee0 || rcv == callee1 || ...
Bit *extra_bit = Bit::MakeNot(gs.guard);
for (size_t cind = 0; cind < callees->GetEdgeCount(); cind++) {
const CallEdge &cedge = callees->GetEdge(cind);
if (cedge.where.id == id && cedge.where.point == point) {
Variable *callee_var = cedge.callee;
callee_var->IncRef();
Exp *callee_exp = Exp::MakeVar(callee_var);
gs.exp->IncRef();
Bit *equal = Exp::MakeCompareBit(B_Equal, callee_exp, gs.exp);
extra_bit = Bit::MakeOr(extra_bit, equal);
}
}
extra_bit->MoveRef(NULL, assume_list);
AssumeInfo info;
info.bit = extra_bit;
assume_list->PushBack(info);
}
}
CalleeCache.Release(id->BaseVar());
}
}
BodyAnnotCache.Release(id->Function());
// add assumptions from heap invariants describing values mentioned
// in added assumptions. we could keep doing this transitively but don't,
// to ensure termination.
size_t count = assume_list->Size();
for (size_t ind = 0; ind < count; ind++) {
InvariantAssumeVisitor visitor(NULL, 0, assume_list);
assume_list->At(ind).bit->DoVisit(&visitor);
}
CombineAssumeList(assume_list);
}
void Visit(Exp *exp)
{
if (ExpFld *nexp = exp->IfFld()) {
// pick up any type invariants from the host type.
String *csu_name = nexp->GetField()->GetCSUType()->GetCSUName();
Vector<BlockCFG*> *annot_list = CompAnnotCache.Lookup(csu_name);
for (size_t ind = 0; annot_list && ind < annot_list->Size(); ind++) {
BlockCFG *annot_cfg = annot_list->At(ind);
Assert(annot_cfg->GetAnnotationKind() == AK_Invariant ||
annot_cfg->GetAnnotationKind() == AK_InvariantAssume);
BlockId *id = annot_cfg->GetId();
Bit *bit = BlockMemory::GetAnnotationBit(annot_cfg);
if (!bit) continue;
// get the *this expression. we'll replace this with the actual CSU
// lvalue to get the assumed bit.
id->IncRef();
Variable *this_var = Variable::Make(id, VK_This, NULL, 0, NULL);
Exp *this_exp = Exp::MakeVar(this_var);
Exp *this_drf = Exp::MakeDrf(this_exp);
Exp *target = nexp->GetTarget();
GuardExpVector lval_res;
if (mcfg) {
mcfg->TranslateExp(TRK_Point, point, target, &lval_res);
}
else {
target->IncRef();
lval_res.PushBack(GuardExp(target, Bit::MakeConstant(true)));
}
for (size_t lind = 0; lind < lval_res.Size(); lind++) {
// ignore the guard component of the result here. this means that
// accessing a field of a value means related invariants hold for
// the value along all paths. which is normally right, except when
// the value is the result of a cast, and could have a different type
// along other paths. TODO: sort this out.
const GuardExp &gs = lval_res[lind];
Bit *new_bit = BitReplaceExp(bit, this_drf, gs.exp);
new_bit->MoveRef(NULL, assume_list);
annot_cfg->IncRef(assume_list);
AssumeInfo info;
info.annot = annot_cfg;
info.point = 0;
info.bit = new_bit;
assume_list->PushBack(info);
}
this_drf->DecRef();
}
CompAnnotCache.Release(csu_name);
}
if (ExpVar *nexp = exp->IfVar()) {
if (nexp->GetVariable()->Kind() == VK_Glob) {
String *var_name = nexp->GetVariable()->GetName();
Vector<BlockCFG*> *annot_list = InitAnnotCache.Lookup(var_name);
for (size_t ind = 0; annot_list && ind < annot_list->Size(); ind++) {
BlockCFG *annot_cfg = annot_list->At(ind);
Assert(annot_cfg->GetAnnotationKind() == AK_Invariant ||
annot_cfg->GetAnnotationKind() == AK_InvariantAssume);
Bit *bit = BlockMemory::GetAnnotationBit(annot_cfg);
if (!bit) continue;
bit->IncRef(assume_list);
annot_cfg->IncRef(assume_list);
AssumeInfo info;
info.annot = annot_cfg;
info.point = 0;
info.bit = bit;
assume_list->PushBack(info);
}
InitAnnotCache.Release(var_name);
}
}
}
void InferSummaries(const Vector<BlockSummary*> &summary_list)
{
static BaseTimer infer_timer("infer_summaries");
Timer _timer(&infer_timer);
if (summary_list.Empty())
return;
Variable *function = summary_list[0]->GetId()->BaseVar();
Vector<BlockCFG*> *annot_list = BodyAnnotCache.Lookup(function->GetName());
// all traces which might refer to the result of pointer arithmetic.
Vector<Exp*> arithmetic_list;
ArithmeticEscape escape(function, arithmetic_list);
// initial pass over the CFGs to get traces used in pointer arithmetic.
for (size_t ind = 0; ind < summary_list.Size(); ind++) {
BlockSummary *sum = summary_list[ind];
BlockCFG *cfg = sum->GetMemory()->GetCFG();
for (size_t eind = 0; eind < cfg->GetEdgeCount(); eind++) {
PEdge *edge = cfg->GetEdge(eind);
if (PEdgeAssign *assign_edge = edge->IfAssign()) {
Exp *left = assign_edge->GetLeftSide();
Exp *right = assign_edge->GetRightSide();
ProcessArithmeticAssign(&escape, cfg->GetId(), left, right);
}
}
}
for (size_t ind = 0; ind < summary_list.Size(); ind++) {
BlockSummary *sum = summary_list[ind];
BlockMemory *mcfg = sum->GetMemory();
BlockCFG *cfg = mcfg->GetCFG();
// accumulate all the assertions at points in the CFG.
Vector<AssertInfo> asserts;
// add assertions at function exit for any postconditions.
if (cfg->GetId()->Kind() == B_Function) {
for (size_t aind = 0; annot_list && aind < annot_list->Size(); aind++) {
BlockCFG *annot_cfg = annot_list->At(aind);
if (annot_cfg->GetAnnotationKind() != AK_Postcondition)
continue;
if (Bit *bit = BlockMemory::GetAnnotationBit(annot_cfg)) {
AssertInfo info;
info.kind = ASK_Annotation;
info.cls = ASC_Check;
info.point = cfg->GetExitPoint();
info.bit = bit;
asserts.PushBack(info);
}
}
}
// add assertions for any point annotations within the CFG.
for (size_t pind = 0; pind < cfg->GetPointAnnotationCount(); pind++) {
PointAnnotation pann = cfg->GetPointAnnotation(pind);
BlockCFG *annot_cfg = GetAnnotationCFG(pann.annot);
if (!annot_cfg) continue;
if (annot_cfg->GetAnnotationKind() != AK_Assert)
continue;
if (Bit *bit = BlockMemory::GetAnnotationBit(annot_cfg)) {
AssertInfo info;
info.kind = ASK_Annotation;
info.cls = ASC_Check;
info.point = pann.point;
info.bit = bit;
asserts.PushBack(info);
}
}
for (size_t eind = 0; eind < cfg->GetEdgeCount(); eind++) {
PEdge *edge = cfg->GetEdge(eind);
PPoint point = edge->GetSource();
if (PEdgeAnnotation *nedge = edge->IfAnnotation()) {
// add an assertion for this annotation if it not an assume.
BlockCFG *annot_cfg = GetAnnotationCFG(nedge->GetAnnotationId());
if (!annot_cfg) continue;
if (annot_cfg->GetAnnotationKind() != AK_Assert &&
annot_cfg->GetAnnotationKind() != AK_AssertRuntime) {
continue;
}
if (Bit *bit = BlockMemory::GetAnnotationBit(annot_cfg)) {
AssertInfo info;
info.kind = (annot_cfg->GetAnnotationKind() == AK_Assert)
? ASK_Annotation : ASK_AnnotationRuntime;
info.cls = ASC_Check;
info.point = point;
info.bit = bit;
asserts.PushBack(info);
}
}
// add assertions for any invariants affected by a write.
Exp *left = NULL;
if (PEdgeAssign *nedge = edge->IfAssign())
left = nedge->GetLeftSide();
if (PEdgeCall *nedge = edge->IfCall())
left = nedge->GetReturnValue();
// for now our detection of affected invariants is pretty crude;
// writes to fields can affect type invariants on the field's type
// which use that field, and writes to global variables can affect
// invariants on that global. TODO: pin this down once we draw a
// precise line between which invariants can and can't be checked.
if (left && left->IsFld()) {
ExpFld *nleft = left->AsFld();
String *csu_name = nleft->GetField()->GetCSUType()->GetCSUName();
Vector<BlockCFG*> *comp_annot_list = CompAnnotCache.Lookup(csu_name);
for (size_t aind = 0; comp_annot_list &&
aind < comp_annot_list->Size(); aind++) {
BlockCFG *annot_cfg = comp_annot_list->At(aind);
if (annot_cfg->GetAnnotationKind() != AK_Invariant)
continue;
Bit *bit = BlockMemory::GetAnnotationBit(annot_cfg);
if (!bit) continue;
Vector<Exp*> lval_list;
LvalListVisitor visitor(&lval_list);
bit->DoVisit(&visitor);
bool uses_field = false;
for (size_t ind = 0; ind < lval_list.Size(); ind++) {
if (ExpFld *lval = lval_list[ind]->IfFld()) {
if (lval->GetField() == nleft->GetField())
uses_field = true;
}
}
if (uses_field) {
// this is a type invariant which uses the field being written
// as an lvalue. we need to assert this write preserves
// the invariant.
BlockId *id = annot_cfg->GetId();
Variable *this_var = Variable::Make(id, VK_This, NULL, 0, NULL);
Exp *this_exp = Exp::MakeVar(this_var);
Exp *this_drf = Exp::MakeDrf(this_exp);
Bit *new_bit = BitReplaceExp(bit, this_drf, nleft->GetTarget());
AssertInfo info;
info.kind = ASK_Invariant;
info.cls = ASC_Check;
info.point = point;
info.bit = new_bit;
asserts.PushBack(info);
}
}
CompAnnotCache.Release(csu_name);
}
if (left && left->IsVar()) {
Variable *var = left->AsVar()->GetVariable();
if (var->Kind() == VK_Glob) {
Vector<BlockCFG*> *glob_annot_list =
InitAnnotCache.Lookup(var->GetName());
for (size_t aind = 0; glob_annot_list &&
aind < glob_annot_list->Size(); aind++) {
BlockCFG *annot_cfg = glob_annot_list->At(aind);
Bit *bit = BlockMemory::GetAnnotationBit(annot_cfg);
if (!bit) continue;
AssertInfo info;
info.kind = ASK_Invariant;
info.cls = ASC_Check;
info.point = point;
info.bit = bit;
asserts.PushBack(info);
}
InitAnnotCache.Release(var->GetName());
}
}
if (PEdgeCall *nedge = edge->IfCall()) {
// add assertions for any callee preconditions.
// pull preconditions from both direct and indirect calls.
Vector<Variable*> callee_names;
if (Variable *callee = nedge->GetDirectFunction()) {
callee_names.PushBack(callee);
}
else {
CallEdgeSet *callees = CalleeCache.Lookup(function);
if (callees) {
for (size_t cind = 0; cind < callees->GetEdgeCount(); cind++) {
const CallEdge &edge = callees->GetEdge(cind);
if (edge.where.id == cfg->GetId() && edge.where.point == point)
callee_names.PushBack(edge.callee);
}
}
// CalleeCache release is below.
}
for (size_t cind = 0; cind < callee_names.Size(); cind++) {
String *callee = callee_names[cind]->GetName();
Vector<BlockCFG*> *call_annot_list = BodyAnnotCache.Lookup(callee);
for (size_t aind = 0;
call_annot_list && aind < call_annot_list->Size(); aind++) {
BlockCFG *annot_cfg = call_annot_list->At(aind);
if (annot_cfg->GetAnnotationKind() != AK_Precondition)
continue;
if (Bit *bit = BlockMemory::GetAnnotationBit(annot_cfg)) {
ConvertCallsiteMapper mapper(cfg, point, false);
Bit *caller_bit = bit->DoMap(&mapper);
if (!caller_bit)
continue;
AssertInfo info;
info.kind = ASK_Annotation;
info.cls = ASC_Check;
info.point = point;
info.bit = caller_bit;
asserts.PushBack(info);
}
}
BodyAnnotCache.Release(callee);
}
if (!nedge->GetDirectFunction())
CalleeCache.Release(function);
}
BufferScanVisitor write_visitor(asserts, arithmetic_list, point, true);
BufferScanVisitor read_visitor(asserts, arithmetic_list, point, false);
IntegerScanVisitor integer_visitor(asserts, point);
GCScanVisitor gcsafe_visitor(asserts, point);
// only look at the written lvalues for the write visitor.
if (PEdgeAssign *assign = edge->IfAssign())
write_visitor.Visit(assign->GetLeftSide());
if (PEdgeCall *call = edge->IfCall()) {
if (Exp *returned = call->GetReturnValue())
write_visitor.Visit(returned);
}
edge->DoVisit(&read_visitor);
// disable integer overflow visitor for now.
// edge->DoVisit(&integer_visitor);
edge->DoVisit(&gcsafe_visitor);
}
if (cfg->GetId()->Kind() == B_Function) {
BlockModset *modset = GetBlockModset(cfg->GetId());
if (modset->CanGC()) {
AssertInfo info;
info.kind = ASK_CanGC;
info.cls = ASC_Check;
info.point = cfg->GetExitPoint();
String *name = cfg->GetId()->BaseVar()->GetName();
Variable *var = Variable::Make(NULL, VK_Glob, name, 0, name);
Exp *varexp = Exp::MakeVar(var);
Exp *gcsafe = Exp::MakeGCSafe(varexp, false);
info.bit = Bit::MakeVar(gcsafe);
asserts.PushBack(info);
}
}
MarkRedundantAssertions(mcfg, asserts);
// move the finished assertion list into the summary.
for (size_t ind = 0; ind < asserts.Size(); ind++) {
const AssertInfo &info = asserts[ind];
sum->AddAssert(info.kind, info.cls, info.point, info.bit);
}
}
// infer delta and termination invariants for all summaries.
for (size_t ind = 0; ind < summary_list.Size(); ind++)
InferInvariants(summary_list[ind], arithmetic_list);
BodyAnnotCache.Release(function->GetName());
}
void init(int n) {
up.init(n);
dn.init(n);
nt.init(n);
}
void TestClass::TestDecimalToBinary()
{
Bit bit;
bit.DecimalToBinary("32.72");
}
void TestClass::TestUpdateBits()
{
Bit bit;
int result = bit.UpdateBit(2048, 21, 2, 6);
assert(result == 2132);
}
void TestClass::TestSwapBits()
{
Bit bit;
bit.SwapBits(14);
}
void TestClass::TestBitDistance()
{
Bit bit;
assert( 2 == bit.BitDistance(31, 14));
}