1"""
2Tests the builtin formats of LLDB.
3"""
4
5import lldb
6from lldbsuite.test.decorators import *
7from lldbsuite.test.lldbtest import *
8from lldbsuite.test import lldbutil
9
10class TestCase(TestBase):
11
12    mydir = TestBase.compute_mydir(__file__)
13
14    def getFormatted(self, format, expr):
15        """
16        Evaluates the expression and formats the result with the given format.
17        """
18        result = lldb.SBCommandReturnObject()
19        full_expr = "expr --format '" + format + "' -- " + expr
20        self.dbg.GetCommandInterpreter().HandleCommand(full_expr, result)
21        self.assertTrue(result.Succeeded(), result.GetError())
22        return result.GetOutput()
23
24    @no_debug_info_test
25    @skipIfWindows
26    # uint128_t not available on arm.
27    @skipIf(archs=['arm', 'aarch64'])
28    def test(self):
29        self.build()
30        lldbutil.run_to_source_breakpoint(self, "// break here", lldb.SBFileSpec("main.cpp"))
31
32        # void
33        self.assertEqual("", self.getFormatted("void", "1"))
34
35        # boolean
36        self.assertIn("= false\n", self.getFormatted("boolean", "0"))
37        self.assertIn("= true\n", self.getFormatted("boolean", "1"))
38        self.assertIn("= true\n", self.getFormatted("boolean", "2"))
39        self.assertIn("= error: unsupported byte size (16) for boolean format\n", self.getFormatted("boolean", "(__uint128_t)0"))
40
41        # float
42        self.assertIn("= 0\n", self.getFormatted("float", "0"))
43        self.assertIn("= 2\n", self.getFormatted("float", "0x40000000"))
44        self.assertIn("= NaN\n", self.getFormatted("float", "-1"))
45        # Checks the float16 code.
46        self.assertIn("= 2\n", self.getFormatted("float", "(__UINT16_TYPE__)0x4000"))
47        self.assertIn("= error: unsupported byte size (1) for float format\n", self.getFormatted("float", "'a'"))
48
49        # enumeration
50        self.assertIn("= 0\n", self.getFormatted("enumeration", "0"))
51        self.assertIn("= 1234567\n", self.getFormatted("enumeration", "1234567"))
52        self.assertIn("= -1234567\n", self.getFormatted("enumeration", "-1234567"))
53
54        # dec
55        self.assertIn("= 1234567\n", self.getFormatted("dec", "1234567"))
56        self.assertIn("= 123456789\n", self.getFormatted("dec", "(__uint128_t)123456789"))
57
58        # unsigned decimal
59        self.assertIn("= 1234567\n", self.getFormatted("unsigned decimal", "1234567"))
60        self.assertIn("= 4293732729\n", self.getFormatted("unsigned decimal", "-1234567"))
61        self.assertIn("= 123456789\n", self.getFormatted("unsigned decimal", "(__uint128_t)123456789"))
62
63        # octal
64        self.assertIn("= 04553207\n", self.getFormatted("octal", "1234567"))
65        self.assertIn("= 0221505317046536757\n", self.getFormatted("octal", "(__uint128_t)0x123456789ABDEFull"))
66
67        # complex float
68        self.assertIn("= error: unsupported byte size (1) for complex float format\n", self.getFormatted("complex float", "'a'"))
69
70        # complex integer
71        self.assertIn("= error: unsupported byte size (1) for complex integer format\n", self.getFormatted("complex integer", "'a'"))
72
73        # hex
74        self.assertIn("= 0x00abc123\n", self.getFormatted("hex", "0xABC123"))
75        self.assertIn("= 0x000000000000000000123456789abdef\n", self.getFormatted("hex", "(__uint128_t)0x123456789ABDEFull"))
76
77        # hex float
78        self.assertIn("= 0x1p1\n", self.getFormatted("hex float", "2.0f"))
79        self.assertIn("= 0x1p1\n", self.getFormatted("hex float", "2.0"))
80        # FIXME: long double not supported.
81        self.assertIn("= error: unsupported byte size (16) for hex float format\n", self.getFormatted("hex float", "2.0l"))
82
83        # uppercase hex
84        self.assertIn("= 0x00ABC123\n", self.getFormatted("uppercase hex", "0xABC123"))
85
86        # binary
87        self.assertIn("= 0b00000000000000000000000000000010\n", self.getFormatted("binary", "2"))
88        self.assertIn("= 0b01100001\n", self.getFormatted("binary", "'a'"))
89        self.assertIn(" = 0b10010001101000101011001111000\n", self.getFormatted("binary", "(__uint128_t)0x12345678ll"))
90
91        # Different character arrays.
92        # FIXME: Passing a 'const char *' will ignore any given format,
93        self.assertIn(r'= " \U0000001b\a\b\f\n\r\t\vaA09\0"', self.getFormatted("character array", "cstring"))
94        self.assertIn(r'= " \U0000001b\a\b\f\n\r\t\vaA09\0"', self.getFormatted("c-string", "cstring"))
95        self.assertIn(' = " \\e\\a\\b\\f\\n\\r\\t\\vaA09" " \\U0000001b\\a\\b\\f\\n\\r\\t\\vaA09"\n',
96                      self.getFormatted("c-string", "(char *)cstring"))
97        self.assertIn('=\n', self.getFormatted("c-string", "(__UINT64_TYPE__)0"))
98
99        # Build a uint128_t that contains a series of characters in each byte.
100        # First 8 byte of the uint128_t.
101        cstring_chars1 = " \a\b\f\n\r\t\v"
102        # Last 8 byte of the uint128_t.
103        cstring_chars2 = "AZaz09\033\0"
104
105        # Build a uint128_t value with the hex encoded characters.
106        string_expr = "((__uint128_t)0x"
107        for c in cstring_chars1:
108             string_expr += format(ord(c), "x").zfill(2)
109        string_expr += "ull << 64) | (__uint128_t)0x"
110        for c in cstring_chars2:
111             string_expr += format(ord(c), "x").zfill(2)
112        string_expr += "ull"
113
114        # Try to print that uint128_t with the different char formatters.
115        self.assertIn('= \\0\\e90zaZA\\v\\t\\r\\n\\f\\b\\a \n', self.getFormatted("character array", string_expr))
116        self.assertIn('= \\0\\e90zaZA\\v\\t\\r\\n\\f\\b\\a \n', self.getFormatted("character", string_expr))
117        self.assertIn('= ..90zaZA....... \n', self.getFormatted("printable character", string_expr))
118        self.assertIn('= 0x00 0x1b 0x39 0x30 0x7a 0x61 0x5a 0x41 0x0b 0x09 0x0d 0x0a 0x0c 0x08 0x07 0x20\n', self.getFormatted("unicode8", string_expr))
119
120        # OSType
121        ostype_expr = "(__UINT64_TYPE__)0x"
122        for c in cstring_chars1:
123             ostype_expr += format(ord(c), "x").zfill(2)
124        self.assertIn("= ' \\a\\b\\f\\n\\r\\t\\v'\n", self.getFormatted("OSType", ostype_expr))
125
126        ostype_expr = "(__UINT64_TYPE__)0x"
127        for c in cstring_chars2:
128             ostype_expr += format(ord(c), "x").zfill(2)
129        self.assertIn("= 'AZaz09\\e\\0'\n", self.getFormatted("OSType", ostype_expr))
130
131        self.assertIn('= 0x2007080c0a0d090b415a617a30391b00\n', self.getFormatted("OSType", string_expr))
132
133        # bytes
134        self.assertIn(r'= " \U0000001b\a\b\f\n\r\t\vaA09\0"', self.getFormatted("bytes", "cstring"))
135
136        # bytes with ASCII
137        self.assertIn(r'= " \U0000001b\a\b\f\n\r\t\vaA09\0"', self.getFormatted("bytes with ASCII", "cstring"))
138
139        # unicode8
140        self.assertIn('= 0x78 0x56 0x34 0x12\n', self.getFormatted("unicode8", "0x12345678"))
141
142        # unicode16
143        self.assertIn('= U+5678 U+1234\n', self.getFormatted("unicode16", "0x12345678"))
144
145        # unicode32
146        self.assertIn('= U+0x89abcdef U+0x01234567\n', self.getFormatted("unicode32", "(__UINT64_TYPE__)0x123456789ABCDEFll"))
147
148        # address
149        self.assertIn("= 0x00000012\n", self.getFormatted("address", "0x12"))
150        self.assertIn("= 0x00000000\n", self.getFormatted("address", "0"))
151
152        # Different fixed-width integer type arrays (e.g. 'uint8_t[]').
153        self.assertIn("= {0xf8 0x56 0x34 0x12}\n", self.getFormatted("uint8_t[]", "0x123456f8"))
154        self.assertIn("= {-8 86 52 18}\n", self.getFormatted("int8_t[]", "0x123456f8"))
155
156        self.assertIn("= {0x56f8 0x1234}\n", self.getFormatted("uint16_t[]", "0x123456f8"))
157        self.assertIn("= {-2312 4660}\n", self.getFormatted("int16_t[]", "0x1234F6f8"))
158
159        self.assertIn("= {0x89abcdef 0x01234567}\n", self.getFormatted("uint32_t[]", "(__UINT64_TYPE__)0x123456789ABCDEFll"))
160        self.assertIn("= {-1985229329 19088743}\n", self.getFormatted("int32_t[]", "(__UINT64_TYPE__)0x123456789ABCDEFll"))
161
162        self.assertIn("= {0x89abcdef 0x01234567 0x00000000 0x00000000}\n", self.getFormatted("uint32_t[]", "__uint128_t i = 0x123456789ABCDEF; i"))
163        self.assertIn("= {-1985229329 19088743 0 0}\n", self.getFormatted("int32_t[]", "__uint128_t i = 0x123456789ABCDEF; i"))
164
165        self.assertIn("= {0x0123456789abcdef 0x0000000000000000}\n", self.getFormatted("uint64_t[]", "__uint128_t i = 0x123456789ABCDEF; i"))
166        self.assertIn("= {-994074541749903617 0}\n", self.getFormatted("int64_t[]", "__uint128_t i = 0xF23456789ABCDEFFll; i"))
167
168        # There is not int128_t[] style, so this only tests uint128_t[].
169        self.assertIn("= {0x00000000000000000123456789abcdef}\n", self.getFormatted("uint128_t[]", "__uint128_t i = 0x123456789ABCDEF; i"))
170
171        # Different fixed-width float type arrays.
172        self.assertIn("{2 2}\n", self.getFormatted("float16[]", "0x40004000"))
173        self.assertIn("{2 2}\n", self.getFormatted("float32[]", "0x4000000040000000ll"))
174        self.assertIn("{2 0}\n", self.getFormatted("float64[]", "__uint128_t i = 0x4000000000000000ll; i"))
175
176        # Invalid format string
177        self.expect("expr --format invalid_format_string -- 1", error=True,
178                    substrs=["error: Invalid format character or name 'invalid_format_string'. Valid values are:"])
179
180    # Extends to host target pointer width.
181    @skipIf(archs=no_match(['x86_64']))
182    @no_debug_info_test
183    def test_pointer(self):
184        # pointer
185        self.assertIn("= 0x000000000012d687\n", self.getFormatted("pointer", "1234567"))
186        self.assertIn("= 0x0000000000000000\n", self.getFormatted("pointer", "0"))
187        # FIXME: Just ignores the input value as it's not pointer sized.
188        self.assertIn("= 0x0000000000000000\n", self.getFormatted("pointer", "'a'"))
189
190    # Depends on the host target for decoding.
191    @skipIf(archs=no_match(['x86_64']))
192    @no_debug_info_test
193    def test_instruction(self):
194        self.assertIn("  addq   0xa(%rdi), %r8\n", self.getFormatted("instruction", "0x0a47034c"))
195