bridges/source/cpp_uno/gcc3_linux_intel/call.s

   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
  23 privateSnippetExecutorGeneral:
  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
  45 privateSnippetExecutorVoid:
  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
  65 privateSnippetExecutorHyper:
  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
  88 privateSnippetExecutorFloat:
  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
 110 privateSnippetExecutorDouble:
 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
 132 privateSnippetExecutorClass:
 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     .section .note.gnu.property,"a"
 294     .p2align 2
 295     .long     1f - 0f
 296     .long     4f - 1f
 297     .long     5
 298 0:
 299     .string     "GNU"
 300 1:
 301     .p2align 2
 302     .long     0xc0000002
 303     .long     3f - 2f
 304 2:
 305     .long     0x3
 306 3:
 307     .p2align 2
 308 4: