load_complex and store_complex instructions (#309)

* Start adding the load_complex and store_complex instructions.

N.b.:
The text format is not correct yet. Requires changes to the lexer and parser.
I'm not sure why I needed to change the RuntimeError to Exception yet. Will fix.

* Get first few encodings of load_complex working. Still needs var args type checking.

* Clean up ModRM helper functions in binemit.

* Implement 32-bit displace for load_complex

* Use encoding helpers instead of doing them all by hand

* Initial implementation of store_complex

* Parse value list for load/store_complex with + as delimiter. Looks nice.

* Add sign/zero-extension and size variants for load_complex.

* Add size variants of store_complex.

* Add asm helper lines to load/store complex bin tests.

* Example of length-checking the instruction ValueList for an encoding. Extremely questionable implementation.

* Fix Python linting issues

* First draft of postopt pass to fold adds and loads into load_complex. Just simple loads for now.

* Optimization pass now works with all types of loads.

* Add store+add -> store_complex to postopt pass

* Put complex address optimization behind ISA flag.

* Add load/store complex for f32 and f64

* Fixes changes to lexer that broke NaN parsing.

Abstracts away the repeated checks for whether or not the characters
following a + or - are going to be parsed as a number or not.

* Fix formatting issues

* Fix register restrictions for complex addresses.

* Encoding tests for x86-32.

* Add documentation for newly added instructions, recipes, and cdsl changes.

* Fix python formatting again

* Apply value-list length predicates to all LoadComplex and StoreComplex instructions.

* Add predicate types to new encoding helpers for mypy.

* Import FieldPredicate to satisfy mypy.

* Add and fix some "asm" strings in the encoding tests.

* Line-up 'bin' comments in x86/binary64 test

* Test parsing of offset-less store_complex instruction.

* 'sNaN' not 'sNan'

* Bounds check the lookup for polymorphic typevar operand.

* Fix encodings for istore16_complex.

lib/codegen/meta/cdsl/formats.py

@@ -103,6 +103,19 @@ class InstructionFormat(object):
         InstructionFormat._registry[sig] = self
         InstructionFormat.all_formats.append(self)
 
+    def args(self):
+        # type: () -> FormatField
+        """
+        Provides a ValueListField, which is derived from FormatField,
+        corresponding to the full ValueList of the instruction format. This
+        is useful for creating predicates for instructions which use variadic
+        arguments.
+        """
+
+        if self.has_value_list:
+            return ValueListField(self)
+        return None
+
     def _process_member_names(self, kinds):
         # type: (Sequence[Union[OperandKind, Tuple[str, OperandKind]]]) -> Iterable[FormatField]  # noqa
         """
@@ -210,7 +223,7 @@ class FormatField(object):
     This corresponds to a single member of a variant of the `InstructionData`
     data type.
 
-    :param iformat: Parent `InstructionFormat`.
+    :param iform: Parent `InstructionFormat`.
     :param immnum: Immediate operand number in parent.
     :param kind: Immediate Operand kind.
     :param member: Member name in `InstructionData` variant.
@@ -227,6 +240,29 @@ class FormatField(object):
         # type: () -> str
         return '{}.{}'.format(self.format.name, self.member)
 
+    def rust_destructuring_name(self):
+        # type: () -> str
+        return self.member
+
     def rust_name(self):
         # type: () -> str
         return self.member
+
+
+class ValueListField(FormatField):
+    """
+    The full value list field of an instruction format.
+
+    This corresponds to all Value-type members of a variant of the
+    `InstructionData` format, which contains a ValueList.
+
+    :param iform: Parent `InstructionFormat`.
+    """
+    def __init__(self, iform):
+        # type: (InstructionFormat) -> None
+        self.format = iform
+        self.member = "args"
+
+    def rust_destructuring_name(self):
+        # type: () -> str
+        return 'ref {}'.format(self.member)