Assembly: minimally support GAS assembly output

malfet · Jul 5, 2017 · 8375c37 · 8375c37
1 parent 886f382
commit 8375c37
Show file tree

Hide file tree

Showing 5 changed files with 80 additions and 24 deletions.
diff --git a/peachpy/x86_64/function.py b/peachpy/x86_64/function.py
@@ -1486,11 +1486,38 @@ def format(self, assembly_format="peachpy", line_separator=os.linesep):
             code = ["TEXT " + ",".join(text_arguments)]
             if self.go_signature is not None:
                 code.insert(0, "// " + self.go_signature)
+        elif assembly_format == "gas":
+            from peachpy.util import ilog2
+            code_alignment = 16
+            code = [
+                "#ifdef __APPLE__",
+                ".section __TEXT,__text,regular,pure_instructions",
+                ".globl _{name}".format(name=self.mangled_name),
+                ".p2align {ilog2alignment}, 0x90".format(
+                    ilog2alignment=ilog2(code_alignment)),
+                "_{name}:".format(name=self.mangled_name),
+                "#else /* !__APPLE__ */",
+                ".text",
+                ".p2align {ilog2alignment},,{max_alignment_bytes}".format(
+                    ilog2alignment=ilog2(code_alignment),
+                    max_alignment_bytes=code_alignment - 1),
+                ".globl " + self.mangled_name,
+                ".type {name}, @function".format(name=self.mangled_name),
+                "{name}:".format(name=self.mangled_name),
+                "#endif /* !__APPLE */",
+            ]
         else:
             code = []
 
         code.extend(self.format_code(assembly_format, line_separator=None, indent=True))
-        if assembly_format == "go":
+        if assembly_format == "gas":
+            code += [
+                "#ifndef __APPLE__",
+                ".size {name}, .-{name}".format(name=self.mangled_name),
+                "#endif /* !__APPLE__ */",
+            ]
+
+        if assembly_format in ["go", "gas"]:
             # Add trailing line or assembler will refuse to compile
             code.append("")
         if line_separator is None:

diff --git a/peachpy/x86_64/instructions.py b/peachpy/x86_64/instructions.py
@@ -65,7 +65,10 @@ def format(self, assembly_format, indent):
         elif assembly_format == "nasm":
             return text + str(self)
         elif assembly_format == "gas":
-            return text + str(self)
+            if self.operands:
+                return text + self.gas_name + " " + ", ".join(format_operand(op, assembly_format) for op in reversed(self.operands))
+            else:
+                return text + self.gas_name
         elif assembly_format == "go":
             if self.go_name:
                 from peachpy.util import is_int

diff --git a/peachpy/x86_64/operand.py b/peachpy/x86_64/operand.py
@@ -64,12 +64,12 @@ def get_operand_registers(operand):
 
 
 def format_operand(operand, assembly_format):
-    assert assembly_format in {"peachpy", "gnu", "nasm", "go"}, \
-        "Supported assembly formats are 'peachpy', 'gnu', 'nasm', 'go'"
+    assert assembly_format in {"peachpy", "gas", "nasm", "go"}, \
+        "Supported assembly formats are 'peachpy', 'gas', 'nasm', 'go'"
 
     immediate_prefix_map = {
         "peachpy": "",
-        "gnu": "$",
+        "gas": "$",
         "nasm": "",
         "go": "$"
     }
@@ -303,8 +303,8 @@ def __call__(self, mask):
         return MemoryOperand(self.address, self.size, mask)
 
     def format(self, assembly_format):
-        assert assembly_format in {"peachpy", "gnu", "nasm", "go"}, \
-            "Supported assembly formats are 'peachpy', 'gnu', 'nasm', 'go'"
+        assert assembly_format in {"peachpy", "gas", "nasm", "go"}, \
+            "Supported assembly formats are 'peachpy', 'gas', 'nasm', 'go'"
 
         if assembly_format == "go":
             text = str(self.address.displacement)
@@ -313,8 +313,21 @@ def format(self, assembly_format):
             if self.address.index is not None:
                 text += "(%s*%d)" % (self.address.index.format(assembly_format), self.address.scale)
             return text
-        elif assembly_format == "gnu":
-            return "%" + str(self)
+        elif assembly_format == "gas":
+            if isinstance(self.address, RIPRelativeOffset):
+                return str(self.address.offset) + "(%%rip)"
+            else:
+                base = self.address.base
+                if self.address.index is None:
+                    return "{displacement}({base})".format(
+                        displacement=self.address.displacement,
+                        base=base.format(assembly_format))
+                else:
+                    return "{displacement}({base},{index},{scale})".format(
+                        displacement=self.address.displacement,
+                        base="" if base is None else base.format(assembly_format),
+                        index=self.address.index,
+                        scale=self.address.scale)
         else:
             return str(self)
 

diff --git a/peachpy/x86_64/pseudo.py b/peachpy/x86_64/pseudo.py
@@ -30,8 +30,8 @@ def __str__(self):
         return ".".join(map(str, self.name))
 
     def format(self, assembly_format):
-        assert assembly_format in {"peachpy", "gnu", "nasm", "go"}, \
-            "Supported assembly formats are 'peachpy', 'gnu', 'nasm', 'go'"
+        assert assembly_format in {"peachpy", "gas", "nasm", "go"}, \
+            "Supported assembly formats are 'peachpy', 'gas', 'nasm', 'go'"
 
         if assembly_format == "go":
             # Go assembler rejects label names with a dot, so we replace it with underscore symbol
@@ -60,8 +60,8 @@ def __str__(self):
         return ".".join(map(str, self.identifier)) + ":"
 
     def format(self, assembly_format, indent):
-        assert assembly_format in {"peachpy", "gnu", "nasm", "go"}, \
-            "Supported assembly formats are 'peachpy', 'gnu', 'nasm', 'go'"
+        assert assembly_format in {"peachpy", "gas", "nasm", "go"}, \
+            "Supported assembly formats are 'peachpy', 'gas', 'nasm', 'go'"
 
         if assembly_format == "go":
             # Go assembler rejects label names with a dot, so we replace it with underscore symbol

diff --git a/peachpy/x86_64/registers.py b/peachpy/x86_64/registers.py
@@ -226,14 +226,14 @@ def as_qword(self):
         return GeneralPurposeRegister64(self.physical_id, self.virtual_id)
 
     def format(self, assembly_format):
-        assert assembly_format in {"peachpy", "gnu", "nasm", "go"}, \
-            "Supported assembly formats are 'peachpy', 'gnu', 'nasm', 'go'"
+        assert assembly_format in {"peachpy", "gas", "nasm", "go"}, \
+            "Supported assembly formats are 'peachpy', 'gas', 'nasm', 'go'"
 
         if assembly_format == "go":
             assert not self.is_virtual, \
                 "Go assembler does not support virtual registers"
             return GeneralPurposeRegister._go_physical_id_map[self.physical_id]
-        elif assembly_format == "gnu":
+        elif assembly_format == "gas":
             return "%" + str(self)
         else:
             return str(self)
@@ -433,8 +433,8 @@ def __str__(self):
             return GeneralPurposeRegister8._physical_id_map[(self.physical_id, self.mask)]
 
     def format(self, assembly_format):
-        assert assembly_format in {"peachpy", "gnu", "nasm", "go"}, \
-            "Supported assembly formats are 'peachpy', 'gnu', 'nasm', 'go'"
+        assert assembly_format in {"peachpy", "gas", "nasm", "go"}, \
+            "Supported assembly formats are 'peachpy', 'gas', 'nasm', 'go'"
 
         if assembly_format == "go":
             assert not self.is_virtual, \
@@ -490,14 +490,14 @@ def __str__(self):
             return MMXRegister._physical_id_map[self.physical_id]
 
     def format(self, assembly_format):
-        assert assembly_format in {"peachpy", "gnu", "nasm", "go"}, \
-            "Supported assembly formats are 'peachpy', 'gnu', 'nasm', 'go'"
+        assert assembly_format in {"peachpy", "gas", "nasm", "go"}, \
+            "Supported assembly formats are 'peachpy', 'gas', 'nasm', 'go'"
 
         if assembly_format == "go":
             assert not self.is_virtual, \
                 "Go assembler does not support virtual registers"
             return MMXRegister._go_physical_id_map[self.physical_id]
-        elif assembly_format == "gnu":
+        elif assembly_format == "gas":
             return "%" + str(self)
         else:
             return str(self)
@@ -537,14 +537,14 @@ def __str__(self):
             return XMMRegister._physical_id_map[self.physical_id]
 
     def format(self, assembly_format):
-        assert assembly_format in {"peachpy", "gnu", "nasm", "go"}, \
-            "Supported assembly formats are 'peachpy', 'gnu', 'nasm', 'go'"
+        assert assembly_format in {"peachpy", "gas", "nasm", "go"}, \
+            "Supported assembly formats are 'peachpy', 'gas', 'nasm', 'go'"
 
         if assembly_format == "go":
             assert not self.is_virtual, \
                 "Go assembler does not support virtual registers"
             return XMMRegister._go_physical_id_map[self.physical_id]
-        elif assembly_format == "gnu":
+        elif assembly_format == "gas":
             return "%" + str(self)
         else:
             return str(self)
@@ -649,6 +649,19 @@ def __str__(self):
         else:
             return YMMRegister._physical_id_map[self.physical_id]
 
+    def format(self, assembly_format):
+        assert assembly_format in {"peachpy", "gas", "nasm", "go"}, \
+            "Supported assembly formats are 'peachpy', 'gas', 'nasm', 'go'"
+
+        if assembly_format == "go":
+            assert not self.is_virtual, \
+                "Go assembler does not support virtual registers"
+            return XMMRegister._go_physical_id_map[self.physical_id]
+        elif assembly_format == "gas":
+            return "%" + str(self)
+        else:
+            return str(self)
+
     @property
     def as_xmm(self):
         return XMMRegister(self.physical_id, self.virtual_id)