Change the value-preserving fp/bv conversions to be named consistently, collapse signed/unsigned into a parameter, change the pattern-preserving fp/bv conversions to be named consistently, remove simuvex from CI

Author: rhelmot

.gitlab-ci.yml

@@ -11,10 +11,6 @@ lint:
     tags: [angr]
 
 ### first level
-simuvex:
-    script: "angr-test simuvex"
-    tags: [angr]
-
 angr:
     script: "angr-test angr"
     tags: [angr]

.travis.yml

@@ -2,7 +2,6 @@ sudo: required
 dist: trusty
 env:
   - PY=e ANGR_REPO=claripy
-  - PY=e ANGR_REPO=simuvex
   - PY=e ANGR_REPO=angr
   - PY=e ANGR_REPO=angr-bf
   - PY=e ANGR_REPO=angr-doc

appveyor.yml

@@ -13,6 +13,6 @@ install:
 test_script:
 - cmd: |
     cd \angr-dev
-    tests\appveyor_test.bat claripy simuvex angr
+    tests\appveyor_test.bat claripy angr
 
 build: off

claripy/ast/bits.py

@@ -25,7 +25,7 @@ def size(self):
     def _type_name(self):
         return self.__class__.__name__ + str(self.length)
 
-    def to_bv(self):
+    def raw_to_bv(self):
         """
         Converts this data's bit-pattern to a bitvector.
         """

claripy/ast/bv.py

@@ -130,52 +130,42 @@ def _from_str(like, value): #pylint:disable=unused-argument
     def _from_BVV(like, value): #pylint:disable=unused-argument
         return BVV(value.value, value.size())
 
-    def signed_to_fp(self, sort, rm=None):
+    def val_to_fp(self, sort, signed=True, rm=None):
         """
-        Interpret this bitvector as a signed integer, and return the floating-point representation of that integer.
+        Interpret this bitvector as an integer, and return the floating-point representation of that integer.
 
         :param sort:    The sort of floating point value to return
+        :param signed:  Optional: whether this value is a signed integer
         :param rm:      Optional: the rounding mode to use
-        :return:        An FP AST
+        :return:        An FP AST whose value is the same as this BV
         """
         if rm is None:
             rm = fp.fp.RM.default()
         if sort is None:
             sort = fp.fp.FSort.from_size(self.length)
 
-        return fp.fpToFP(rm, self, sort)
-
-    def unsigned_to_fp(self, sort, rm=None):
-        """
-        Interpret this bitvector as an unsigned integer, and return the floating-point representation of that integer.
-
-        :param sort:    The sort of floating point value to return
-        :param rm:      Optional: the rounding mode to use
-        :return:        An FP AST
-        """
-        if rm is None:
-            rm = fp.fp.RM.default()
-        if sort is None:
-            sort = fp.fp.FSort.from_size(self.length)
-
-        return fp.fpToFPUnsigned(rm, self, sort)
+        op = fp.fpToFP if signed else fp.fpToFPUnsigned
+        return op(rm, self, sort)
 
     def raw_to_fp(self):
         """
         Interpret the bits of this bitvector as an IEEE754 floating point number.
-        The inverse of this function is to_bv.
+        The inverse of this function is raw_to_bv.
 
-        :return:        An FP AST
+        :return:        An FP AST whose bit-pattern is the same as this BV
         """
         sort = fp.fp.FSort.from_size(self.length)
         return fp.fpToFP(self, sort)
 
-    def to_bv(self):
+    def raw_to_bv(self):
         """
-        A counterpart to FP.to_bv - does nothing and returns itself.
+        A counterpart to FP.raw_to_bv - does nothing and returns itself.
         """
         return self
 
+    def to_bv(self):
+        return self.raw_to_bv()
+
 def BVS(name, size, min=None, max=None, stride=None, uninitialized=False,  #pylint:disable=redefined-builtin
         explicit_name=None, discrete_set=False, discrete_set_max_card=None, **kwargs):
     """

claripy/ast/fp.py

@@ -30,15 +30,33 @@ def raw_to_fp(self):
         """
         return self
 
-    def to_bv(self):
+    def raw_to_bv(self):
         """
         Interpret the bit-pattern of this IEEE754 floating point number as a bitvector.
         The inverse of this function is to_bv.
 
-        :return:        A BV AST
+        :return:        A BV AST whose bit-pattern is the same as this FP
         """
         return fpToIEEEBV(self)
 
+    def to_bv(self):
+        return self.raw_to_bv()
+
+    def val_to_bv(self, size, signed=True, rm=None):
+        """
+        Convert this floating point value to an integer.
+
+        :param size:    The size of the bitvector to return
+        :param signed:  Optional: Whether the target integer is signed
+        :param rm:      Optional: The rounding mode to use
+        :return:        A bitvector whose value is the rounded version of this FP's value
+        """
+        if rm is None:
+            rm = fp.RM.default()
+
+        op = fpToSBV if signed else fpToUBV
+        return op(rm, self, size)
+
     @property
     def sort(self):
         return fp.FSort.from_size(self.length)