1/*
2 * This file is part of the LibreOffice project.
3 *
4 * This Source Code Form is subject to the terms of the Mozilla Public
5 * License, v. 2.0. If a copy of the MPL was not distributed with this
6 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7 *
8 * This file incorporates work covered by the following license notice:
9 *
10 *   Licensed to the Apache Software Foundation (ASF) under one or more
11 *   contributor license agreements. See the NOTICE file distributed
12 *   with this work for additional information regarding copyright
13 *   ownership. The ASF licenses this file to you under the Apache
14 *   License, Version 2.0 (the "License"); you may not use this file
15 *   except in compliance with the License. You may obtain a copy of
16 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
17 */
18
19    .text
20
21.globl privateSnippetExecutorGeneral
22    .type   privateSnippetExecutorGeneral,@function
23privateSnippetExecutorGeneral:
24.LFBg:
25    movl    %esp,%ecx
26    pushl   %ebp              # proper stack frame needed for exception handling
27.LCFIg0:
28    movl    %esp,%ebp
29.LCFIg1:
30    subl    $0x8,%esp         # 32bit returnValue, and preserve potential 128bit
31                              #  stack alignment
32    pushl   %esp              # 32bit &returnValue
33    pushl   %ecx              # 32bit pCallStack
34    pushl   %edx              # 32bit nVtableOffset
35    pushl   %eax              # 32bit nFunctionIndex
36    call    cpp_vtable_call
37    movl    16(%esp),%eax     # 32bit returnValue
38    leave
39    ret
40.LFEg:
41    .size   privateSnippetExecutorGeneral,.-privateSnippetExecutorGeneral
42
43.globl privateSnippetExecutorVoid
44    .type   privateSnippetExecutorVoid,@function
45privateSnippetExecutorVoid:
46.LFBv:
47    movl    %esp,%ecx
48    pushl   %ebp              # proper stack frame needed for exception handling
49.LCFIv0:
50    movl    %esp,%ebp
51.LCFIv1:
52    andl    $0xFFFFFFF0,%esp  # preserve potential 128bit stack alignment
53    pushl   $0                # 32bit null pointer (returnValue not used)
54    pushl   %ecx              # 32bit pCallStack
55    pushl   %edx              # 32bit nVtableOffset
56    pushl   %eax              # 32bit nFunctionIndex
57    call    cpp_vtable_call
58    leave
59    ret
60.LFEv:
61    .size   privateSnippetExecutorVoid,.-privateSnippetExecutorVoid
62
63.globl privateSnippetExecutorHyper
64    .type   privateSnippetExecutorHyper,@function
65privateSnippetExecutorHyper:
66.LFBh:
67    movl    %esp,%ecx
68    pushl   %ebp              # proper stack frame needed for exception handling
69.LCFIh0:
70    movl    %esp,%ebp
71.LCFIh1:
72    subl    $0x8,%esp         # 64bit returnValue (preserves potential 128bit
73                              #  stack alignment)
74    pushl   %esp              # 32bit &returnValue
75    pushl   %ecx              # 32bit pCallStack
76    pushl   %edx              # 32bit nVtableOffset
77    pushl   %eax              # 32bit nFunctionIndex
78    call    cpp_vtable_call
79    movl    16(%esp),%eax     # 64bit returnValue, lower half
80    movl    20(%esp),%edx     # 64bit returnValue, upper half
81    leave
82    ret
83.LFEh:
84    .size   privateSnippetExecutorHyper,.-privateSnippetExecutorHyper
85
86.globl privateSnippetExecutorFloat
87    .type   privateSnippetExecutorFloat,@function
88privateSnippetExecutorFloat:
89.LFBf:
90    movl    %esp,%ecx
91    pushl   %ebp              # proper stack frame needed for exception handling
92.LCFIf0:
93    movl    %esp,%ebp
94.LCFIf1:
95    subl    $0x8,%esp         # 32bit returnValue, and preserve potential 128bit
96                              #  stack alignment
97    pushl   %esp              # 32bit &returnValue
98    pushl   %ecx              # 32bit pCallStack
99    pushl   %edx              # 32bit nVtableOffset
100    pushl   %eax              # 32bit nFunctionIndex
101    call    cpp_vtable_call
102    flds    16(%esp)          # 32bit returnValue
103    leave
104    ret
105.LFEf:
106    .size   privateSnippetExecutorFloat,.-privateSnippetExecutorFloat
107
108.globl privateSnippetExecutorDouble
109    .type   privateSnippetExecutorDouble,@function
110privateSnippetExecutorDouble:
111.LFBd:
112    movl    %esp,%ecx
113    pushl   %ebp              # proper stack frame needed for exception handling
114.LCFId0:
115    movl    %esp,%ebp
116.LCFId1:
117    subl    $0x8,%esp         # 64bit returnValue (preserves potential 128bit
118                              #  stack alignment)
119    pushl   %esp              # 32bit &returnValue
120    pushl   %ecx              # 32bit pCallStack
121    pushl   %edx              # 32bit nVtableOffset
122    pushl   %eax              # 32bit nFunctionIndex
123    call    cpp_vtable_call
124    fldl    16(%esp)          # 64bit returnValue
125    leave
126    ret
127.LFEd:
128    .size   privateSnippetExecutorDouble,.-privateSnippetExecutorDouble
129
130.globl privateSnippetExecutorClass
131    .type   privateSnippetExecutorClass,@function
132privateSnippetExecutorClass:
133.LFBc:
134    movl    %esp,%ecx
135    pushl   %ebp              # proper stack frame needed for exception handling
136.LCFIc0:
137    movl    %esp,%ebp
138.LCFIc1:
139    subl    $0x8,%esp         # 32bit returnValue, and preserve potential 128bit
140                              #  stack alignment
141    pushl   %esp              # 32bit &returnValue
142    pushl   %ecx              # 32bit pCallStack
143    pushl   %edx              # 32bit nVtableOffset
144    pushl   %eax              # 32bit nFunctionIndex
145    call    cpp_vtable_call
146    movl    16(%esp),%eax     # 32bit returnValue
147    leave
148    ret     $4
149.LFEc:
150    .size   privateSnippetExecutorClass,.-privateSnippetExecutorClass
151
152    .section .eh_frame,"a",@progbits
153.Lframe1:
154    .long   .LECIE1-.LSCIE1   # length
155.LSCIE1:
156    .long   0                 # CIE_ID
157    .byte   1                 # version
158    .string "zR"              # augmentation
159    .uleb128 1                # code_alignment_factor
160    .sleb128 -4               # data_alignment_factor
161    .byte   8                 # return_address_register
162    .uleb128 1                # augmentation size 1:
163    .byte   0x1B              #  FDE Encoding (pcrel sdata4)
164                              # initial_instructions:
165    .byte   0x0C              #  DW_CFA_def_cfa %esp, 4
166    .uleb128 4
167    .uleb128 4
168    .byte   0x88              #  DW_CFA_offset ret, 1
169    .uleb128 1
170    .align 4
171.LECIE1:
172.LSFDEg:
173    .long   .LEFDEg-.LASFDEg  # length
174.LASFDEg:
175    .long   .LASFDEg-.Lframe1 # CIE_pointer
176    .long   .LFBg-.           # initial_location
177    .long   .LFEg-.LFBg       # address_range
178    .uleb128 0                # augmentation size 0
179                              # instructions:
180    .byte   0x04              #  DW_CFA_advance_loc4
181    .long   .LCFIg0-.LFBg
182    .byte   0x0E              #  DW_CFA_def_cfa_offset 8
183    .uleb128 8
184    .byte   0x85              #  DW_CFA_offset %ebp, 2
185    .uleb128 2
186    .byte   0x04              #  DW_CFA_advance_loc4
187    .long   .LCFIg1-.LCFIg0
188    .byte   0x0D              #  DW_CFA_def_cfa_register %ebp
189    .uleb128 5
190    .align 4
191.LEFDEg:
192.LSFDEv:
193    .long   .LEFDEv-.LASFDEv  # length
194.LASFDEv:
195    .long   .LASFDEv-.Lframe1 # CIE_pointer
196    .long   .LFBv-.           # initial_location
197    .long   .LFEv-.LFBv       # address_range
198    .uleb128 0                # augmentation size 0
199                              # instructions:
200    .byte   0x04              #  DW_CFA_advance_loc4
201    .long   .LCFIv0-.LFBv
202    .byte   0x0E              #  DW_CFA_def_cfa_offset 8
203    .uleb128 8
204    .byte   0x85              #  DW_CFA_offset %ebp, 2
205    .uleb128 2
206    .byte   0x04              #  DW_CFA_advance_loc4
207    .long   .LCFIv1-.LCFIv0
208    .byte   0x0D              #  DW_CFA_def_cfa_register %ebp
209    .uleb128 5
210    .align 4
211.LEFDEv:
212.LSFDEh:
213    .long   .LEFDEh-.LASFDEh  # length
214.LASFDEh:
215    .long   .LASFDEh-.Lframe1 # CIE_pointer
216    .long   .LFBh-.           # initial_location
217    .long   .LFEh-.LFBh       # address_range
218    .uleb128 0                # augmentation size 0
219                              # instructions:
220    .byte   0x04              #  DW_CFA_advance_loc4
221    .long   .LCFIh0-.LFBh
222    .byte   0x0E              #  DW_CFA_def_cfa_offset 8
223    .uleb128 8
224    .byte   0x85              #  DW_CFA_offset %ebp, 2
225    .uleb128 2
226    .byte   0x04              #  DW_CFA_advance_loc4
227    .long   .LCFIh1-.LCFIh0
228    .byte   0x0D              #  DW_CFA_def_cfa_register %ebp
229    .uleb128 5
230    .align 4
231.LEFDEh:
232.LSFDEf:
233    .long   .LEFDEf-.LASFDEf  # length
234.LASFDEf:
235    .long   .LASFDEf-.Lframe1 # CIE_pointer
236    .long   .LFBf-.           # initial_location
237    .long   .LFEf-.LFBf       # address_range
238    .uleb128 0                # augmentation size 0
239                              # instructions:
240    .byte   0x04              #  DW_CFA_advance_loc4
241    .long   .LCFIf0-.LFBf
242    .byte   0x0E              #  DW_CFA_def_cfa_offset 8
243    .uleb128 8
244    .byte   0x85              #  DW_CFA_offset %ebp, 2
245    .uleb128 2
246    .byte   0x04              #  DW_CFA_advance_loc4
247    .long   .LCFIf1-.LCFIf0
248    .byte   0x0D              #  DW_CFA_def_cfa_register %ebp
249    .uleb128 5
250    .align 4
251.LEFDEf:
252.LSFDEd:
253    .long   .LEFDEd-.LASFDEd  # length
254.LASFDEd:
255    .long   .LASFDEd-.Lframe1 # CIE_pointer
256    .long   .LFBd-.           # initial_location
257    .long   .LFEd-.LFBd       # address_range
258    .uleb128 0                # augmentation size 0
259                              # instructions:
260    .byte   0x04              #  DW_CFA_advance_loc4
261    .long   .LCFId0-.LFBd
262    .byte   0x0E              #  DW_CFA_def_cfa_offset 8
263    .uleb128 8
264    .byte   0x85              #  DW_CFA_offset %ebp, 2
265    .uleb128 2
266    .byte   0x04              #  DW_CFA_advance_loc4
267    .long   .LCFId1-.LCFId0
268    .byte   0x0D              #  DW_CFA_def_cfa_register %ebp
269    .uleb128 5
270    .align 4
271.LEFDEd:
272.LSFDEc:
273    .long   .LEFDEc-.LASFDEc  # length
274.LASFDEc:
275    .long   .LASFDEc-.Lframe1 # CIE_pointer
276    .long   .LFBc-.           # initial_location
277    .long   .LFEc-.LFBc       # address_range
278    .uleb128 0                # augmentation size 0
279                              # instructions:
280    .byte   0x04              #  DW_CFA_advance_loc4
281    .long   .LCFIc0-.LFBc
282    .byte   0x0E              #  DW_CFA_def_cfa_offset 8
283    .uleb128 8
284    .byte   0x85              #  DW_CFA_offset %ebp, 2
285    .uleb128 2
286    .byte   0x04              #  DW_CFA_advance_loc4
287    .long   .LCFIc1-.LCFIc0
288    .byte   0x0D              #  DW_CFA_def_cfa_register %ebp
289    .uleb128 5
290    .align 4
291.LEFDEc:
292    .section .note.GNU-stack,"",@progbits
293