C++ FixedBits::getValue方法代码示例

Result bvConcatBothWays(vector<FixedBits*>& children, FixedBits& output)
{
  Result r = NO_CHANGE;
  const size_t numberOfChildren = children.size();
  unsigned current = 0;
  for (int i = (int)numberOfChildren - 1; i >= 0;
       i--) // least significant is last.
  {
    FixedBits& child = *children[i];
    for (unsigned j = 0; j < child.getWidth(); j++)
    {
      // values are different. Bad.
      if (output.isFixed(current) && child.isFixed(j) &&
          (output.getValue(current) != child.getValue(j)))
        return CONFLICT;

      if (output.isFixed(current) && !child.isFixed(j))
      {
        // only output is fixed.
        child.setFixed(j, true);
        child.setValue(j, output.getValue(current));
        r = CHANGED;
      }
      else if (!output.isFixed(current) && child.isFixed(j))
      {
        // only input is fixed.
        output.setFixed(current, true);
        output.setValue(current, child.getValue(j));
        r = CHANGED;
      }
      current++;
    }
  }
  return r;
}

Result bvNotBothWays(FixedBits& a, FixedBits& output)
{
  assert(a.getWidth() == output.getWidth());
  const int bitWidth = a.getWidth();

  Result result = NO_CHANGE;

  for (int i = 0; i < bitWidth; i++)
  {
    // error if they are the same.
    if (a.isFixed(i) && output.isFixed(i) &&
        (a.getValue(i) == output.getValue(i)))
    {
      return CONFLICT;
    }

    if (a.isFixed(i) && !output.isFixed(i))
    {
      output.setFixed(i, true);
      output.setValue(i, !a.getValue(i));
      result = CHANGED;
    }

    if (output.isFixed(i) && !a.isFixed(i))
    {
      a.setFixed(i, true);
      a.setValue(i, !output.getValue(i));
      result = CHANGED;
    }
  }
  return result;
}

Result makeEqual(FixedBits& a, FixedBits& b, unsigned from, unsigned to)
{
  assert(to >= from);
  assert(from <= a.getWidth());
  assert(from <= b.getWidth());

  Result result = NO_CHANGE;
  for (unsigned i = from; i < to; i++)
  {
    if (a.isFixed(i) && !b.isFixed(i))
    {
      b.setFixed(i, true);
      b.setValue(i, a.getValue(i));
      result = CHANGED;
    }
    else if (b.isFixed(i) && !a.isFixed(i))
    {
      a.setFixed(i, true);
      a.setValue(i, b.getValue(i));
      result = CHANGED;
    }
    else if (b.isFixed(i) && a.isFixed(i))
    {
      if (a.getValue(i) != b.getValue(i))
        return CONFLICT;
    }
  }
  return result;
}

// if output bit is true. Fix all the operands.
// if all the operands are fixed. Fix the output.
// given 1,1,1,- == 0, fix - to 0.
Result bvAndBothWays(vector<FixedBits*>& operands, FixedBits& output)
{
  Result result = NO_CHANGE;
  const int bitWidth = output.getWidth();

  for (int i = 0; i < bitWidth; i++)
  {
    const stats status = getStats(operands, i);

    // output is fixed to one. But an input value is false!
    if (output.isFixed(i) && output.getValue(i) && status.fixedToZero > 0)
      return CONFLICT;

    // output is fixed to one. But an input value is false!
    if (output.isFixed(i) && !output.getValue(i) && status.fixedToZero == 0 &&
        status.unfixed == 0)
      return CONFLICT;

    // output is fixed to one. So all should be one.
    if (output.isFixed(i) && output.getValue(i) && status.unfixed > 0)
    {
      fixUnfixedTo(operands, i, true);
      result = CHANGED;
    }

    // The output is unfixed. At least one input is false.
    if (!output.isFixed(i) && status.fixedToZero > 0)
    {
      output.setFixed(i, true);
      output.setValue(i, false);
      result = CHANGED;
    }

    // Everything is fixed to one!
    if (!output.isFixed(i) && status.fixedToZero == 0 && status.unfixed == 0)
    {
      output.setFixed(i, true);
      output.setValue(i, true);
      result = CHANGED;
    }

    // If the output is false, and there is a single unfixed value with
    // everything else true..
    if (output.isFixed(i) && !output.getValue(i) && status.fixedToZero == 0 &&
        status.unfixed == 1)
    {
      fixUnfixedTo(operands, i, false);
      result = CHANGED;
    }
  }
  return result;
}

Result bvExtractBothWays(vector<FixedBits*>& children, FixedBits& output)
{
  const size_t numberOfChildren = children.size();
  const unsigned outputBitWidth = output.getWidth();

  Result result = NO_CHANGE;

  assert(3 == numberOfChildren);

  unsigned top = children[1]->getUnsignedValue();
  unsigned bottom = children[2]->getUnsignedValue();

  FixedBits& input = *(children[0]);

  assert(top >= bottom);
  assert(top - bottom + 1 == outputBitWidth);
  assert(top < input.getWidth());

  for (unsigned outputPosition = 0; outputPosition < outputBitWidth;
       outputPosition++)
  {
    unsigned inputPosition = outputPosition + bottom;

    if (input.isFixed(inputPosition) && output.isFixed(outputPosition))
      if (input.getValue(inputPosition) ^ output.getValue(outputPosition))
        return CONFLICT;

    if (input.isFixed(inputPosition) ^ output.isFixed(outputPosition))
    {
      if (input.isFixed(inputPosition))
      {
        output.setFixed(outputPosition, true);
        output.setValue(outputPosition, input.getValue(inputPosition));
        result = CHANGED;
      }
      else
      {
        input.setFixed(inputPosition, true);
        input.setValue(inputPosition, output.getValue(outputPosition));
        result = CHANGED;
      }
    }
  }

  // cerr << "extract[" << top << ":" << bottom << "]" << input << "=" <<
  // output<< endl;

  return result;
}

Result bvSignExtendBothWays(vector<FixedBits*>& children, FixedBits& output)
{
  assert(children.size() == 2);
  // The second argument is a junk size arugment.

  FixedBits& input = *children[0];
  const int inputBitWidth = input.getWidth();
  const int outputBitWidth = output.getWidth();
  assert(inputBitWidth <= outputBitWidth);

  Result result = makeEqual(input, output, 0, inputBitWidth);
  if (CONFLICT == result)
    return CONFLICT;

  // If any of the topmost bits of the output are fixed. Then they all should
  // be.
  // They should all be fixed to the same value.
  bool found = false;
  bool setTo;
  for (int i = inputBitWidth - /**/ 1 /**/; i < outputBitWidth; i++)
  {
    if (output.isFixed(i))
    {
      setTo = output.getValue(i);
      found = true;
      break;
    }
  }

  if (found)
  {
    for (int i = inputBitWidth - 1; i < outputBitWidth; i++)
    {
      if (output.isFixed(i) && (output.getValue(i) != setTo))
        return CONFLICT; // if any are set to the wrong value! bad.
      else if (!output.isFixed(i))
      {
        output.setFixed(i, true);
        output.setValue(i, setTo);
        result = CHANGED;
      }
    }

    Result result2 = makeEqual(input, output, 0, inputBitWidth);
    if (CONFLICT == result2)
      return CONFLICT;
  }
  return result;
}

Result bvZeroExtendBothWays(vector<FixedBits*>& children, FixedBits& output)
{
  assert(children.size() == 2);
  // The second argument is a junk size arugment.

  FixedBits& input = *children[0];
  const int inputBitWidth = input.getWidth();
  const int outputBitWidth = output.getWidth();

  Result result = makeEqual(input, output, 0, inputBitWidth);
  if (CONFLICT == result)
    return CONFLICT;

  // Fix all the topmost bits of the output to zero.
  for (int i = inputBitWidth; i < outputBitWidth; i++)
  {
    if (output.isFixed(i) && output.getValue(i))
      return CONFLICT; // set to one. Never right.
    else if (!output.isFixed(i))
    {
      output.setFixed(i, true);
      output.setValue(i, false);
      result = CHANGED;
    }
  }
  return result;
}

void setUnsignedMinMax(const FixedBits& v, CBV min, CBV max)
{
  CONSTANTBV::BitVector_Fill(max);
  CONSTANTBV::BitVector_Empty(min);

  for (unsigned i = 0; i < v.getWidth(); i++)
  {
    if (v.isFixed(i))
    {
      if (v.getValue(i)) // if it's on. It's on.

      {
        // CONSTANTBV::BitVector_Bit_On(max, i);
        CONSTANTBV::BitVector_Bit_On(min, i);
      }
      else
      {
        CONSTANTBV::BitVector_Bit_Off(max, i);
        // CONSTANTBV::BitVector_Bit_Off(min, i);
      }
    }
    // else // not fixed. Just set the max.
    //{
    //	CONSTANTBV::BitVector_Bit_On(max, i);
    //	CONSTANTBV::BitVector_Bit_Off(min, i);
    //}
  }
  assert(CONSTANTBV::BitVector_Lexicompare(min, max) <= 0);
}

    // If the bits are totally fixed, then return a new matching ASTNode.
    ASTNode
    bitsToNode(const ASTNode& node, const FixedBits& bits)
    {
      ASTNode result;
      STPMgr & beev = *node.GetSTPMgr();

      assert (bits.isTotallyFixed());
      assert (!node.isConstant()); // Peformance. Shouldn't waste time calling it on constants.

      if (node.GetType() == BOOLEAN_TYPE)
        {
          if (bits.getValue(0))
            {
              result = beev.CreateNode(TRUE);
            }
          else
            {
              result = beev.CreateNode(FALSE);
            }
        }
      else if (node.GetType() == BITVECTOR_TYPE)
        {
          result = beev.CreateBVConst(bits.GetBVConst(), node.GetValueWidth());
        }
      else
        FatalError("sadf234s");

      assert(result.isConstant());
      return result;
    }

Result bvXorBothWays(vector<FixedBits*>& operands, FixedBits& output)
{
  Result result = NO_CHANGE;
  const int bitWidth = output.getWidth();

  for (int i = 0; i < bitWidth; i++)
  {
    const stats status = getStats(operands, i);

    if (status.unfixed == 0) // if they are all fixed. We know the answer.
    {
      bool answer = (status.fixedToOne % 2) != 0;

      if (!output.isFixed(i))
      {
        output.setFixed(i, true);
        output.setValue(i, answer);
        result = CHANGED;
      }
      else if (output.getValue(i) != answer)
        return CONFLICT;
    }
    else if (status.unfixed == 1 && output.isFixed(i))
    {
      // If there is just one unfixed, and we have the answer --> We know the
      // value.
      bool soFar = ((status.fixedToOne % 2) != 0);
      if (soFar != output.getValue(i))
      { // result needs to be flipped.
        fixUnfixedTo(operands, i, true);
      }
      else
        fixUnfixedTo(operands, i, false);
      result = CHANGED;
    }
  }
  return result;
}

void setSignedMinMax(FixedBits& v, CBV min, CBV max)
{
  const unsigned int msb = v.getWidth() - 1;

  for (unsigned i = 0; i < (unsigned)v.getWidth(); i++)
  {
    if (v.isFixed(i))
    {
      if (v.getValue(i)) // if it's on. It's on.

      {
        CONSTANTBV::BitVector_Bit_On(max, i);
        CONSTANTBV::BitVector_Bit_On(min, i);
      }
      else
      {
        CONSTANTBV::BitVector_Bit_Off(max, i);
        CONSTANTBV::BitVector_Bit_Off(min, i);
      }
    }
    else
    {
      if (i != msb)
      { // not fixed. Make the maximum Maximum.
        CONSTANTBV::BitVector_Bit_On(max, i);
        CONSTANTBV::BitVector_Bit_Off(min, i);
      }
      else
      { // except for the msb. Where we reduce the min.
        CONSTANTBV::BitVector_Bit_On(min, i);
        CONSTANTBV::BitVector_Bit_Off(max, i);
      }
    }
  }
  assert(CONSTANTBV::BitVector_Compare(min, max) <= 0);
}

Result bvAddBothWays(vector<FixedBits*>& children, FixedBits& output)
{
        const size_t numberOfChildren = children.size();
        if (numberOfChildren==2)
        {
          return bvAddBothWays(*children[0],*children[1],output);
        }

	const unsigned bitWidth = output.getWidth();


	for (size_t i = 0; i < numberOfChildren; i++)
	{
		assert(children[i]->getWidth() == bitWidth );
	}

	int columnL[bitWidth]; // minimum  ""            ""
	int columnH[bitWidth]; // maximum number of true partial products.

	initialiseColumnCounts(columnL, columnH, bitWidth, numberOfChildren, children);

	int sumH[bitWidth];
	int sumL[bitWidth];
	sumL[0] = columnL[0];
	sumH[0] = columnH[0];

	for (unsigned i = /**/1 /**/; i < (unsigned) bitWidth; i++)
	{
		assert((columnH[i] >= columnL[i]) && (columnL[i] >= 0));
		sumH[i] = columnH[i] + (sumH[i - 1] / 2);
		sumL[i] = columnL[i] + (sumL[i - 1] / 2);
	}

	// Now the sums counts are all updated. And consistent with each other.

	bool changed = true;
	while (changed)
	{
		changed = false;

		// Make sure each column's sum is consistent with the output.
		for (unsigned i = 0; i < bitWidth; i++)
		{
			if (output.isFixed(i))
			{
				int expected = output.getValue(i) ? 1 : 0;

				// output is true. So the maximum and minimum can only be even.
				if (sumH[i] % 2 != expected)
				{
					sumH[i]--;
					changed = true;
				}
				if (sumL[i] % 2 != expected)
				{
					sumL[i]++;
					changed = true;
				}

				if (changed && ((sumH[i] < sumL[i]) || (sumL[i] < 0)))
					return CONFLICT;
			}
		}

		// update the column counts to make them consistent to the totals.
		for (unsigned i = /**/0 /**/; i < bitWidth; i++)
		{
			if (sumH[i] < columnH[i])
			{
				columnH[i]--;
				changed = true;

				if (columnH[i] < columnL[i])
					return CONFLICT;
			}
		}

		// Go from low to high making each of the sums consistent.
		for (unsigned i = /**/1 /**/; i < bitWidth; i++)
		{
			assert((columnH[i] >= columnL[i]) && (columnL[i] >= 0));
			if (sumH[i] > columnH[i] + (sumH[i - 1] / 2))
			{
				sumH[i] = columnH[i] + (sumH[i - 1] / 2);
				changed = true;
			}
			if (sumL[i] < columnL[i] + (sumL[i - 1] / 2))
			{
				sumL[i] = columnL[i] + (sumL[i - 1] / 2);
				changed = true;
			}

			if (changed && (sumH[i] < sumL[i] || sumL[i] < 0))
				return CONFLICT;

		}

		// go from high to low, making each of the sums consistent.
		for (int i = /**/(int)bitWidth - 1 /**/; i >= 1; i--)
		{
//.........这里部分代码省略.........

// if a==b then fix the result to true.
// if a!=b then fix the result to false.
Result bvEqualsBothWays(FixedBits& a, FixedBits& b, FixedBits& output)
{
  assert(a.getWidth() == b.getWidth());
  assert(1 == output.getWidth());

  const int childWidth = a.getWidth();

  Result r = NO_CHANGE;

  bool allSame = true;
  bool definatelyFalse = false;

  for (int i = 0; i < childWidth; i++)
  {
    // if both fixed
    if (a.isFixed(i) && b.isFixed(i))
    {
      // And have different values.
      if (a.getValue(i) != b.getValue(i))
      {
        definatelyFalse = true;
        break;
      }
      else
      {
        allSame &= true;
        continue;
      }
    }
    allSame &= false;
  }

  if (definatelyFalse)
  {
    if (output.isFixed(0) && output.getValue(0))
    {
      return CONFLICT;
    }
    else if (!output.isFixed(0))
    {
      output.setFixed(0, true);
      output.setValue(0, false);
      r = CHANGED;
    }
  }
  else if (allSame)
  {
    if (output.isFixed(0) && !output.getValue(0))
    {
      return CONFLICT;
    }
    else if (!output.isFixed(0))
    {
      output.setFixed(0, true);
      output.setValue(0, true);
      r = CHANGED;
    }
  }

  if (output.isFixed(0) && output.getValue(0)) // all should be the same.
  {
    for (int i = 0; i < childWidth; i++)
    {
      if (a.isFixed(i) && b.isFixed(i))
      {
        if (a.getValue(i) != b.getValue(i))
        {
          return CONFLICT;
        }
      }
      else if (a.isFixed(i) != b.isFixed(i)) // both same but only one is fixed.
      {
        if (a.isFixed(i))
        {
          b.setFixed(i, true);
          b.setValue(i, a.getValue(i));
          r = CHANGED;
        }
        else
        {
          a.setFixed(i, true);
          a.setValue(i, b.getValue(i));
          r = CHANGED;
        }
      }
    }
  }

  // if the result is fixed to false, there is a single unspecied value, and all
  // the rest are the same. Fix it to the opposite.
  if (output.isFixed(0) && !output.getValue(0))
  {
    int unknown = 0;

    for (int i = 0; i < childWidth && unknown < 2; i++)
    {
      if (!a.isFixed(i))
        unknown++;
//.........这里部分代码省略.........

// If the guard is fixed, make equal the appropriate input and output.
// If one input can not possibly be the output. Then set the guard to make it
// the other one.
// If both values are the same. Set the output to that value.
Result bvITEBothWays(vector<FixedBits*>& children, FixedBits& output)
{
  Result result = NO_CHANGE;

  assert(3 == children.size());
  const int bitWidth = output.getWidth();
  FixedBits& guard = *children[0];
  FixedBits& c1 = *children[1];
  FixedBits& c2 = *children[2];

  assert(c1.getWidth() == c2.getWidth());
  assert(output.getWidth() == c2.getWidth());

  if (guard.isFixed(0) && guard.getValue(0))
  { // guard fixed to true. So make (first arg == output)
    result = makeEqual(output, c1, 0, bitWidth);
    if (CONFLICT == result)
      return CONFLICT;
  }
  else if (guard.isFixed(0) && !guard.getValue(0))
  {
    result = makeEqual(output, c2, 0, bitWidth);
    if (CONFLICT == result)
      return CONFLICT;
  }
  else
  {
    for (int i = 0; i < bitWidth; i++)
    {
      if (c1.isFixed(i) && c2.isFixed(i) && (c1.getValue(i) == c2.getValue(i)))
      {

        if (output.isFixed(i) && (output.getValue(i) != c1.getValue(i)))
          return CONFLICT;

        if (!output.isFixed(i))
        {
          output.setFixed(i, true);
          output.setValue(i, c1.getValue(i));
          result = CHANGED;
        }
      }
    }
  }

  bool changed = false;
  if (CHANGED == result)
    changed = true;

  for (int i = 0; i < bitWidth; i++)
  {
    if (output.isFixed(i))
    {
      if (c1.isFixed(i) && (c1.getValue(i) != output.getValue(i)))
      {
        // c1 is fixed to a value that's not the same as the output.
        if (!guard.isFixed(0))
        {
          guard.setFixed(0, true);
          guard.setValue(0, false);
          result = bvITEBothWays(children, output);
          if (CONFLICT == result)
            return CONFLICT;
          changed = true;
        }
        else if (guard.getValue(0))
          return CONFLICT;
      }

      if (c2.isFixed(i) && (c2.getValue(i) != output.getValue(i)))
      {
        // c2 is fixed to a value that's not the same as the output.
        if (!guard.isFixed(0))
        {
          guard.setFixed(0, true);
          guard.setValue(0, true);
          result = bvITEBothWays(children, output);
          if (CONFLICT == result)
            return CONFLICT;
          changed = true;
        }
        else if (!guard.getValue(0))
          return CONFLICT;
      }
    }
  }

  if (result == CONFLICT)
    return CONFLICT;
  if (changed)
    return CHANGED;

  return result;
}

Result bvOrBothWays(vector<FixedBits*>& children, FixedBits& output)
{
  Result r = NO_CHANGE;
  const int numberOfChildren = children.size();
  const int bitWidth = output.getWidth();

  for (int i = 0; i < bitWidth; i++)
  {
    bool answerKnown = output.isFixed(i);
    bool answer = false;
    if (answerKnown)
      answer = output.getValue(i);

    int unks = 0;
    int ones = 0;
    int zeroes = 0;

    for (int j = 0; j < numberOfChildren; j++)
    {
      assert(output.getWidth() == children[j]->getWidth());

      if (!children[j]->isFixed(i))
        unks++;
      else if (children[j]->getValue(i))
        ones++;
      else
        zeroes++;
    }

    if (ones > 0) // Atleast a single one found!

    {
      if (answerKnown && !answer)
        return CONFLICT;

      if (!answerKnown)
      {
        output.setFixed(i, true);
        output.setValue(i, true);
        r = CHANGED;
      }
    }

    if (zeroes == numberOfChildren) // all zeroes.

    {
      if (answerKnown && answer)
        return CONFLICT;

      if (!answerKnown)
      {
        r = CHANGED;
        output.setFixed(i, true);
        output.setValue(i, false);
      }
    }

    if (answerKnown && !answer) // known false

    {
      if (ones > 0)
        return CONFLICT;

      // set all the column to false.

      for (int j = 0; j < numberOfChildren; j++)
      {
        if (!children[j]->isFixed(i))
        {
          r = CHANGED;
          children[j]->setFixed(i, true);
          children[j]->setValue(i, false);
        }
      }
    }

    if (unks == 1 && answerKnown && answer &&
        (zeroes == (numberOfChildren - 1)))
    {
      // A single unknown, everything else is false. The answer is true. So the
      // unknown is true.

      for (int j = 0; j < numberOfChildren; j++)
      {
        if (!children[j]->isFixed(i))
        {
          r = CHANGED;
          children[j]->setFixed(i, true);
          children[j]->setValue(i, true);
        }
      }
    }
  }
  return r;
}