Print this page
    
15254 %ymm registers not restored after signal handler
15367 x86 getfpregs() summons corrupting %xmm ghosts
15333 want x86 /proc xregs support (libc_db, libproc, mdb, etc.)
15336 want libc functions for extended ucontext_t
15334 want ps_lwphandle-specific reg routines
15328 FPU_CW_INIT mistreats reserved bit
15335 i86pc fpu_subr.c isn't really platform-specific
15332 setcontext(2) isn't actually noreturn
15331 need <sys/stdalign.h>
Change-Id: I7060aa86042dfb989f77fc3323c065ea2eafa9ad
Conflicts:
    usr/src/uts/common/fs/proc/prcontrol.c
    usr/src/uts/intel/os/archdep.c
    usr/src/uts/intel/sys/ucontext.h
    usr/src/uts/intel/syscall/getcontext.c
    
      
        | Split | 
	Close | 
      
      | Expand all | 
      | Collapse all | 
    
    
          --- old/usr/src/lib/libc/port/mapfile-vers
          +++ new/usr/src/lib/libc/port/mapfile-vers
   1    1  #
   2    2  # CDDL HEADER START
   3    3  #
   4    4  # The contents of this file are subject to the terms of the
   5    5  # Common Development and Distribution License (the "License").
   6    6  # You may not use this file except in compliance with the License.
   7    7  #
   8    8  # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9    9  # or http://www.opensolaris.org/os/licensing.
  10   10  # See the License for the specific language governing permissions
  11   11  # and limitations under the License.
  12   12  #
  13   13  # When distributing Covered Code, include this CDDL HEADER in each
  14   14  # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15   15  # If applicable, add the following below this CDDL HEADER, with the
  16   16  # fields enclosed by brackets "[]" replaced with your own identifying
  17   17  # information: Portions Copyright [yyyy] [name of copyright owner]
  18   18  #
  19   19  # CDDL HEADER END
  20   20  #
  21   21  
  22   22  #
  23   23  # Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
  24   24  # Copyright 2018 Nexenta Systems, Inc.
  25   25  # Copyright (c) 2012 by Delphix. All rights reserved.
  26   26  # Copyright 2020 Joyent, Inc.
  27   27  # Copyright (c) 2013, OmniTI Computer Consulting, Inc. All rights reserved.
  28   28  # Copyright (c) 2013 Gary Mills
  29   29  # Copyright 2014 Garrett D'Amore <garrett@damore.org>
  30   30  # Copyright 2022 OmniOS Community Edition (OmniOSce) Association.
  31   31  #
  32   32  
  33   33  #
  34   34  # MAPFILE HEADER START
  35   35  #
  36   36  # WARNING:  STOP NOW.  DO NOT MODIFY THIS FILE.
  37   37  # Object versioning must comply with the rules detailed in
  38   38  #
  39   39  #       usr/src/lib/README.mapfiles
  40   40  #
  41   41  # You should not be making modifications here until you've read the most current
  42   42  # copy of that file. If you need help, contact a gatekeeper for guidance.
  43   43  #
  44   44  # MAPFILE HEADER END
  45   45  #
  46   46  
  47   47  $mapfile_version 2
  48   48  
  49   49  #
  50   50  # All function names added to this or any other libc mapfile
  51   51  # must be placed under the 'protected:' designation.
  52   52  # The 'global:' designation is used *only* for data
  53   53  # items and for the members of the malloc() family.
  54   54  #
  55   55  
  56   56  # Mnemonic conditional input identifiers:
  57   57  #
  58   58  # - amd64, i386, sparc32, sparcv9: Correspond to ISA subdirectories used to
  59   59  #       hold per-platform code. Note however that we use 'sparc32' instead of
  60   60  #       'sparc'. Since '_sparc' is predefined to apply to, all sparc platforms,
  61   61  #       naming the 32-bit version 'sparc' would be too likely to cause errors.
  62   62  #
  63   63  # -     lf64: Defined on platforms that offer the 32-bit largefile APIs
  64   64  #
  65   65  $if _ELF32
  66   66  $add lf64
  67   67  $endif
  68   68  $if _sparc && _ELF32
  69   69  $add sparc32
  70   70  $endif
  
    | 
      ↓ open down ↓ | 
    70 lines elided | 
    
      ↑ open up ↑ | 
  
  71   71  $if _sparc && _ELF64
  72   72  $add sparcv9
  73   73  $endif
  74   74  $if _x86 && _ELF32
  75   75  $add i386
  76   76  $endif
  77   77  $if _x86 && _ELF64
  78   78  $add amd64
  79   79  $endif
  80   80  
       81 +SYMBOL_VERSION ILLUMOS_0.41 {
       82 +    protected:
       83 +        getcontext_extd;
       84 +        swapcontext_extd;
       85 +        ucontext_alloc;
       86 +        ucontext_free;
       87 +} ILLUMOS_0.40;
       88 +
  81   89  SYMBOL_VERSION ILLUMOS_0.40 {
  82   90      protected:
  83   91          errc;
  84   92          verrc;
  85   93          vwarnc;
  86   94          warnc;
  87   95  } ILLUMOS_0.39;
  88   96  
  89   97  SYMBOL_VERSION ILLUMOS_0.39 {
  90   98      protected:
  91   99          memrchr;
  92  100  } ILLUMOS_0.38;
  93  101  
  94  102  SYMBOL_VERSION ILLUMOS_0.38 {
  95  103      protected:
  96  104          getgrouplist;
  97  105  } ILLUMOS_0.37;
  98  106  
  99  107  SYMBOL_VERSION ILLUMOS_0.37 {
 100  108      global:
 101  109          __stack_chk_guard       {
 102  110                                    ASSERT = {
 103  111                                            TYPE = OBJECT;
 104  112                                            SIZE = addrsize;
 105  113                                          };
 106  114                                  };
 107  115      protected:
 108  116          __stack_chk_fail;
 109  117  } ILLUMOS_0.36;
 110  118  
 111  119  SYMBOL_VERSION ILLUMOS_0.36 {
 112  120      protected:
 113  121          upanic;
 114  122  } ILLUMOS_0.35;
 115  123  
 116  124  SYMBOL_VERSION ILLUMOS_0.35 {
 117  125      protected:
 118  126          qsort_r;
 119  127  } ILLUMOS_0.34;
 120  128  
 121  129  SYMBOL_VERSION ILLUMOS_0.34 {
 122  130      protected:
 123  131          futimes;
 124  132          lutimes;
 125  133  } ILLUMOS_0.33;
 126  134  
 127  135  SYMBOL_VERSION ILLUMOS_0.33 {
 128  136      protected:
 129  137          c16rtomb;
 130  138          c32rtomb;
 131  139          mbrtoc16;
 132  140          mbrtoc32;
 133  141  } ILLUMOS_0.32;
 134  142  
 135  143  SYMBOL_VERSION ILLUMOS_0.32 {
 136  144      protected:
 137  145          fmemopen;
 138  146          open_memstream;
 139  147          open_wmemstream;
 140  148  } ILLUMOS_0.31;
 141  149  
 142  150  SYMBOL_VERSION ILLUMOS_0.31 {
 143  151      protected:
 144  152          __unlockpt_xpg4;
 145  153  } ILLUMOS_0.30;
 146  154  
 147  155  SYMBOL_VERSION ILLUMOS_0.30 {
 148  156      protected:
 149  157          reallocf;
 150  158  } ILLUMOS_0.29;
 151  159  
 152  160  SYMBOL_VERSION ILLUMOS_0.29 {
 153  161      protected:
 154  162          getrandom;
 155  163  } ILLUMOS_0.28;
 156  164  
 157  165  SYMBOL_VERSION ILLUMOS_0.28 {
 158  166      protected:
 159  167          pthread_attr_getname_np;
 160  168          pthread_attr_setname_np;
 161  169          pthread_getname_np;
 162  170          pthread_setname_np;
 163  171          thr_getname;
 164  172          thr_setname;
 165  173  } ILLUMOS_0.27;
 166  174  
 167  175  SYMBOL_VERSION ILLUMOS_0.27 {   # memset_s(3C) and set_constraint_handler_s(3C)
 168  176      protected:
 169  177          abort_handler_s;
 170  178          ignore_handler_s;
 171  179          memset_s;
 172  180          set_constraint_handler_s;
 173  181  } ILLUMOS_0.26;
 174  182  
 175  183  SYMBOL_VERSION ILLUMOS_0.26 {   # fts(3) LFS
 176  184  $if lf64
 177  185      protected:
 178  186          fts_children64;
 179  187          fts_close64;
 180  188          fts_open64;
 181  189          fts_read64;
 182  190          fts_set64;
 183  191  $endif
 184  192  } ILLUMOS_0.25;
 185  193  
 186  194  SYMBOL_VERSION ILLUMOS_0.25 {   # inet_* moved from libnsl/libsocket
 187  195      protected:
 188  196          inet_addr;
 189  197          inet_aton;
 190  198          inet_lnaof;
 191  199          inet_makeaddr;
 192  200          inet_netof;
 193  201          inet_network;
 194  202          inet_ntoa;
 195  203          inet_ntoa_r;
 196  204          inet_ntop;
 197  205          inet_pton;
 198  206  } ILLUMOS_0.24;
 199  207  
 200  208  SYMBOL_VERSION ILLUMOS_0.24 {   # openbsd compat
 201  209      protected:
 202  210          freezero;
 203  211          recallocarray;
 204  212  } ILLUMOS_0.23;
 205  213  
 206  214  SYMBOL_VERSION ILLUMOS_0.23 {   # openbsd compat
 207  215      protected:
 208  216          fts_children;
 209  217          fts_close;
 210  218          fts_open;
 211  219          fts_read;
 212  220          fts_set;
 213  221          reallocarray;
 214  222          strtonum;
 215  223  } ILLUMOS_0.22;
 216  224  
 217  225  SYMBOL_VERSION ILLUMOS_0.22 {   # endian(3C)
 218  226      protected:
 219  227          htobe16;
 220  228          htobe32;
 221  229          htobe64;
 222  230          htole16;
 223  231          htole32;
 224  232          htole64;
 225  233          betoh16;
 226  234          letoh16;
 227  235          be16toh;
 228  236          le16toh;
 229  237          betoh32;
 230  238          letoh32;
 231  239          be32toh;
 232  240          le32toh;
 233  241          betoh64;
 234  242          letoh64;
 235  243          be64toh;
 236  244          le64toh;
 237  245  } ILLUMOS_0.21;
 238  246  
 239  247  SYMBOL_VERSION ILLUMOS_0.21 {
 240  248      protected:
 241  249          pthread_attr_get_np;
 242  250  } ILLUMOS_0.20;
 243  251  
 244  252  SYMBOL_VERSION ILLUMOS_0.20 {   # C11
 245  253      protected:
 246  254          aligned_alloc;
 247  255          at_quick_exit;
 248  256          call_once;
 249  257          cnd_broadcast;
 250  258          cnd_destroy;
 251  259          cnd_init;
 252  260          cnd_signal;
 253  261          cnd_timedwait;
 254  262          cnd_wait;
 255  263          mtx_destroy;
 256  264          mtx_init;
 257  265          mtx_lock;
 258  266          mtx_timedlock;
 259  267          mtx_trylock;
 260  268          mtx_unlock;
 261  269          quick_exit;
 262  270          thrd_create;
 263  271          thrd_current;
 264  272          thrd_detach;
 265  273          thrd_equal;
 266  274          thrd_exit;
 267  275          thrd_join;
 268  276          thrd_sleep;
 269  277          thrd_yield;
 270  278          timespec_get;
 271  279          tss_create;
 272  280          tss_delete;
 273  281          tss_get;
 274  282          tss_set;
 275  283  } ILLUMOS_0.19;
 276  284  
 277  285  SYMBOL_VERSION ILLUMOS_0.19 {   # flock
 278  286      protected:
 279  287          flock;
 280  288  } ILLUMOS_0.18;
 281  289  
 282  290  SYMBOL_VERSION ILLUMOS_0.18 {   # signalfd
 283  291      protected:
 284  292          signalfd;
 285  293  } ILLUMOS_0.17;
 286  294  
 287  295  SYMBOL_VERSION ILLUMOS_0.17 {   # glob(3C) LFS
 288  296  $if lf64
 289  297      protected:
 290  298          _glob_ext64;
 291  299          _globfree_ext64;
 292  300  $endif
 293  301  } ILLUMOS_0.16;
 294  302  
 295  303  SYMBOL_VERSION ILLUMOS_0.16 {   # timerfd
 296  304      protected:
 297  305          timerfd_create;
 298  306          timerfd_gettime;
 299  307          timerfd_settime;
 300  308  } ILLUMOS_0.15;
 301  309  
 302  310  SYMBOL_VERSION ILLUMOS_0.15 {   # epoll(3C)
 303  311      protected:
 304  312          epoll_create;
 305  313          epoll_create1;
 306  314          epoll_ctl;
 307  315          epoll_wait;
 308  316          epoll_pwait;
 309  317  } ILLUMOS_0.14;
 310  318  
 311  319  SYMBOL_VERSION ILLUMOS_0.14 {   # strerror_l
 312  320      protected:
 313  321          strerror_l;
 314  322  } ILLUMOS_0.13;
 315  323  
 316  324  SYMBOL_VERSION ILLUMOS_0.13 {   # eventfd
 317  325      protected:
 318  326          eventfd;
 319  327          eventfd_read;
 320  328          eventfd_write;
 321  329  } ILLUMOS_0.12;
 322  330  
 323  331  SYMBOL_VERSION ILLUMOS_0.12 {   # arc4random and friends
 324  332      protected:
 325  333          arc4random;
 326  334          arc4random_buf;
 327  335          arc4random_uniform;
 328  336          explicit_bzero;
 329  337          getentropy;
 330  338  } ILLUMOS_0.11;
 331  339  
 332  340  SYMBOL_VERSION ILLUMOS_0.11 {   # Illumos additions
 333  341      protected:
 334  342          iswxdigit_l;
 335  343          isxdigit_l;
 336  344  } ILLUMOS_0.10;
 337  345  
 338  346  SYMBOL_VERSION ILLUMOS_0.10 {   # Illumos additions
 339  347      protected:
 340  348          preadv;
 341  349          pwritev;
 342  350  
 343  351  $if lf64
 344  352          preadv64;
 345  353          pwritev64;
 346  354  $endif
 347  355  } ILLUMOS_0.9;
 348  356  
 349  357  SYMBOL_VERSION ILLUMOS_0.9 {
 350  358      protected:
 351  359          wcsnrtombs;
 352  360          wcsnrtombs_l;
 353  361  } ILLUMOS_0.8;
 354  362  
 355  363  SYMBOL_VERSION ILLUMOS_0.8 {    # POSIX 2008 newlocale and friends
 356  364      protected:
 357  365          __global_locale;
 358  366          __mb_cur_max;
 359  367          __mb_cur_max_l;
 360  368          btowc_l;
 361  369          duplocale;
 362  370          fgetwc_l;
 363  371          freelocale;
 364  372          getwc_l;
 365  373          isalnum_l;
 366  374          isalpha_l;
 367  375          isblank_l;
 368  376          iscntrl_l;
 369  377          isdigit_l;
 370  378          isgraph_l;
 371  379          islower_l;
 372  380          isprint_l;
 373  381          ispunct_l;
 374  382          isspace_l;
 375  383          isupper_l;
 376  384          iswideogram;
 377  385          iswideogram_l;
 378  386          iswnumber;
 379  387          iswnumber_l;
 380  388          iswhexnumber;
 381  389          iswhexnumber_l;
 382  390          iswphonogram;
 383  391          iswphonogram_l;
 384  392          iswspecial;
 385  393          iswspecial_l;
 386  394          iswalnum_l;
 387  395          iswalpha_l;
 388  396          iswblank_l;
 389  397          iswcntrl_l;
 390  398          iswctype_l;
 391  399          iswdigit_l;
 392  400          iswgraph_l;
 393  401          iswlower_l;
 394  402          iswprint_l;
 395  403          iswpunct_l;
 396  404          iswspace_l;
 397  405          iswupper_l;
 398  406          mblen_l;
 399  407          mbrlen_l;
 400  408          mbsinit_l;
 401  409          mbsnrtowcs;
 402  410          mbsnrtowcs_l;
 403  411          mbsrtowcs_l;
 404  412          mbstowcs_l;
 405  413          mbtowc_l;
 406  414          newlocale;
 407  415          nl_langinfo_l;
 408  416          strcasecmp_l;
 409  417          strcasestr_l;
 410  418          strcoll_l;
 411  419          strfmon_l;
 412  420          strftime_l;
 413  421          strncasecmp_l;
 414  422          strptime_l;
 415  423          strxfrm_l;
 416  424          tolower_l;
 417  425          toupper_l;
 418  426          towlower_l;
 419  427          towupper_l;
 420  428          towctrans_l;
 421  429          uselocale;
 422  430          wcrtomb_l;
 423  431          wcscasecmp_l;
 424  432          wcscoll_l;
 425  433          wcsncasecmp_l;
 426  434          wcsrtombs_l;
 427  435          wcstombs_l;
 428  436          wcswidth_l;
 429  437          wcsxfrm_l;
 430  438          wctob_l;
 431  439          wctomb_l;
 432  440          wctrans_l;
 433  441          wctype_l;
 434  442          wcwidth_l;
 435  443  } ILLUMOS_0.7;
 436  444  
 437  445  SYMBOL_VERSION ILLUMOS_0.7 {    # Illumos additions
 438  446      protected:
 439  447          _glob_ext;
 440  448          _globfree_ext;
 441  449  } ILLUMOS_0.6;
 442  450  
 443  451  SYMBOL_VERSION ILLUMOS_0.6 {    # Illumos additions
 444  452      protected:
 445  453          getloginx;
 446  454          getloginx_r;
 447  455          __posix_getloginx_r;
 448  456  } ILLUMOS_0.5;
 449  457  
 450  458  SYMBOL_VERSION ILLUMOS_0.5 {    # common C++ ABI exit handlers
 451  459      protected:
 452  460          __cxa_atexit;
 453  461          __cxa_finalize;
 454  462  } ILLUMOS_0.4;
 455  463  
 456  464  SYMBOL_VERSION ILLUMOS_0.4 {    # Illumos additions
 457  465      protected:
 458  466          pipe2;
 459  467          dup3;
 460  468          mkostemp;
 461  469          mkostemps;
 462  470  
 463  471  $if lf64
 464  472          mkostemp64;
 465  473          mkostemps64;
 466  474  $endif
 467  475  } ILLUMOS_0.3;
 468  476  
 469  477  SYMBOL_VERSION ILLUMOS_0.3 {    # Illumos additions
 470  478      protected:
 471  479          assfail3;
 472  480  } ILLUMOS_0.2;
 473  481  
 474  482  SYMBOL_VERSION ILLUMOS_0.2 {    # Illumos additions
 475  483      protected:
 476  484          posix_spawn_pipe_np;
 477  485  } ILLUMOS_0.1;
 478  486  
 479  487  SYMBOL_VERSION ILLUMOS_0.1 {    # Illumos additions
 480  488      protected:
 481  489          timegm;
 482  490  } SUNW_1.23;
 483  491  
 484  492  SYMBOL_VERSION SUNW_1.23 {      # SunOS 5.11 (Solaris 11)
 485  493      global:
 486  494          _nl_domain_bindings     {
 487  495                                    ASSERT = {
 488  496                                            TYPE = OBJECT;
 489  497                                            SIZE = addrsize;
 490  498                                          };
 491  499                                  };
 492  500          _nl_msg_cat_cntr        {
 493  501                                    ASSERT = {
 494  502                                            TYPE = OBJECT;
 495  503                                            SIZE = 4;
 496  504                                          };
 497  505                                  };
 498  506  
 499  507  $if _ELF32
 500  508          dl_iterate_phdr         {
 501  509                                    TYPE = FUNCTION;
 502  510                                    FILTER = /usr/lib/ld.so.1;
 503  511                                  };
 504  512  $elif sparcv9
 505  513          dl_iterate_phdr         {
 506  514                                    TYPE = FUNCTION;
 507  515                                    FILTER = /usr/lib/sparcv9/ld.so.1;
 508  516                                  };
 509  517  $elif amd64
 510  518          dl_iterate_phdr {
 511  519                                    TYPE = FUNCTION;
 512  520                                    FILTER = /usr/lib/amd64/ld.so.1;
 513  521                                  };
 514  522  $else
 515  523  $error unknown platform
 516  524  $endif
 517  525  
 518  526      protected:
 519  527  
 520  528  $if sparc32
 521  529          __align_cpy_1;
 522  530  $endif
 523  531  
 524  532          addrtosymstr;
 525  533          aio_cancel;
 526  534          aiocancel;
 527  535          aio_error;
 528  536          aio_fsync;
 529  537          aio_read;
 530  538          aioread;
 531  539          aio_return;
 532  540          aio_suspend;
 533  541          aiowait;
 534  542          aio_waitn;
 535  543          aio_write;
 536  544          aiowrite;
 537  545          asprintf;
 538  546          assfail;
 539  547          backtrace;
 540  548          backtrace_symbols;
 541  549          backtrace_symbols_fd;
 542  550          canonicalize_file_name;
 543  551          clearenv;
 544  552          clock_getres;
 545  553          clock_gettime;
 546  554          clock_nanosleep;
 547  555          clock_settime;
 548  556          daemon;
 549  557          dirfd;
 550  558          door_bind;
 551  559          door_call;
 552  560          door_create;
 553  561          door_cred;
 554  562          door_getparam;
 555  563          door_info;
 556  564          door_return;
 557  565          door_revoke;
 558  566          door_server_create;
 559  567          door_setparam;
 560  568          door_ucred;
 561  569          door_unbind;
 562  570          door_xcreate;
 563  571          err;
 564  572          errx;
 565  573          faccessat;
 566  574          fchmodat;
 567  575          fcloseall;
 568  576          fdatasync;
 569  577          ffsl;
 570  578          ffsll;
 571  579          fgetattr;
 572  580          fls;
 573  581          flsl;
 574  582          flsll;
 575  583          forkallx;
 576  584          forkx;
 577  585          fsetattr;
 578  586          getattrat;
 579  587          getdelim;
 580  588          getline;
 581  589          get_nprocs;
 582  590          get_nprocs_conf;
 583  591          getprogname;
 584  592          htonl;
 585  593          htonll;
 586  594          htons;
 587  595          linkat;
 588  596          lio_listio;
 589  597          memmem;
 590  598          mkdirat;
 591  599          mkdtemp;
 592  600          mkfifoat;
 593  601          mknodat;
 594  602          mkstemps;
 595  603          mmapobj;
 596  604          mq_close;
 597  605          mq_getattr;
 598  606          mq_notify;
 599  607          mq_open;
 600  608          mq_receive;
 601  609          mq_reltimedreceive_np;
 602  610          mq_reltimedsend_np;
 603  611          mq_send;
 604  612          mq_setattr;
 605  613          mq_timedreceive;
 606  614          mq_timedsend;
 607  615          mq_unlink;
 608  616          nanosleep;
 609  617          ntohl;
 610  618          ntohll;
 611  619          ntohs;
 612  620          posix_fadvise;
 613  621          posix_fallocate;
 614  622          posix_madvise;
 615  623          posix_memalign;
 616  624          posix_spawn_file_actions_addclosefrom_np;
 617  625          posix_spawnattr_getsigignore_np;
 618  626          posix_spawnattr_setsigignore_np;
 619  627          ppoll;
 620  628          priv_basicset;
 621  629          pthread_key_create_once_np;
 622  630          pthread_mutexattr_getrobust;
 623  631          pthread_mutexattr_setrobust;
 624  632          pthread_mutex_consistent;
 625  633          readlinkat;
 626  634          sched_getparam;
 627  635          sched_get_priority_max;
 628  636          sched_get_priority_min;
 629  637          sched_getscheduler;
 630  638          sched_rr_get_interval;
 631  639          sched_setparam;
 632  640          sched_setscheduler;
 633  641          sched_yield;
 634  642          sem_close;
 635  643          sem_destroy;
 636  644          sem_getvalue;
 637  645          sem_init;
 638  646          sem_open;
 639  647          sem_post;
 640  648          sem_reltimedwait_np;
 641  649          sem_timedwait;
 642  650          sem_trywait;
 643  651          sem_unlink;
 644  652          sem_wait;
 645  653          setattrat;
 646  654          setprogname;
 647  655          _sharefs;
 648  656          shm_open;
 649  657          shm_unlink;
 650  658          sigqueue;
 651  659          sigtimedwait;
 652  660          sigwaitinfo;
 653  661          smt_pause;
 654  662          stpcpy;
 655  663          stpncpy;
 656  664          strcasestr;
 657  665          strchrnul;
 658  666          strndup;
 659  667          strnlen;
 660  668          strnstr;
 661  669          strsep;
 662  670          symlinkat;
 663  671          thr_keycreate_once;
 664  672          timer_create;
 665  673          timer_delete;
 666  674          timer_getoverrun;
 667  675          timer_gettime;
 668  676          timer_settime;
 669  677          u8_strcmp;
 670  678          u8_validate;
 671  679          uconv_u16tou32;
 672  680          uconv_u16tou8;
 673  681          uconv_u32tou16;
 674  682          uconv_u32tou8;
 675  683          uconv_u8tou16;
 676  684          uconv_u8tou32;
 677  685          vasprintf;
 678  686          verr;
 679  687          verrx;
 680  688          vforkx;
 681  689          vwarn;
 682  690          vwarnx;
 683  691          warn;
 684  692          warnx;
 685  693          wcpcpy;
 686  694          wcpncpy;
 687  695          wcscasecmp;
 688  696          wcsdup;
 689  697          wcsncasecmp;
 690  698          wcsnlen;
 691  699  
 692  700  $if lf64
 693  701          aio_cancel64;
 694  702          aio_error64;
 695  703          aio_fsync64;
 696  704          aio_read64;
 697  705          aioread64;
 698  706          aio_return64;
 699  707          aio_suspend64;
 700  708          aio_waitn64;
 701  709          aio_write64;
 702  710          aiowrite64;
 703  711          lio_listio64;
 704  712          mkstemps64;
 705  713          posix_fadvise64;
 706  714          posix_fallocate64;
 707  715  $endif
 708  716  } SUNW_1.22.7;
 709  717  
 710  718  SYMBOL_VERSION SUNW_1.22.7 {    # s10u10 - SunOS 5.10 (Solaris 10) patch additions
 711  719      protected:
 712  720          SUNW_1.22.7;
 713  721  } SUNW_1.22.6;
 714  722  
 715  723  SYMBOL_VERSION SUNW_1.22.6 {    # s10u9 - SunOS 5.10 (Solaris 10) patch additions
 716  724      protected:
 717  725          futimens;
 718  726          utimensat;
 719  727  } SUNW_1.22.5;
 720  728  
 721  729  SYMBOL_VERSION SUNW_1.22.5 {    # s10u8 - SunOS 5.10 (Solaris 10) patch additions
 722  730      protected:
 723  731          getpagesizes2;
 724  732  } SUNW_1.22.4;
 725  733  
 726  734  SYMBOL_VERSION SUNW_1.22.4 {    # s10u7 - SunOS 5.10 (Solaris 10) patch additions
 727  735      protected:
 728  736          SUNW_1.22.4;
 729  737  } SUNW_1.22.3;
 730  738  
 731  739  SYMBOL_VERSION SUNW_1.22.3 {    # SunOS 5.10 (Solaris 10) patch additions
 732  740      protected:
 733  741          mutex_consistent;
 734  742          u8_textprep_str;
 735  743          uucopy;
 736  744          uucopystr;
 737  745  } SUNW_1.22.2;
 738  746  
 739  747  SYMBOL_VERSION SUNW_1.22.2 {    # SunOS 5.10 (Solaris 10) patch additions
 740  748      protected:
 741  749          is_system_labeled;
 742  750          ucred_getlabel;
 743  751          _ucred_getlabel;
 744  752  } SUNW_1.22.1;
 745  753  
 746  754  SYMBOL_VERSION SUNW_1.22.1 {    # SunOS 5.10 (Solaris 10) patch additions
 747  755      protected:
 748  756          atomic_add_8;
 749  757          atomic_add_8_nv;
 750  758          atomic_add_char         { FLAGS = NODYNSORT; };
 751  759          atomic_add_char_nv      { FLAGS = NODYNSORT; };
 752  760          atomic_add_int          { FLAGS = NODYNSORT; };
 753  761          atomic_add_int_nv       { FLAGS = NODYNSORT; };
 754  762          atomic_add_ptr          { FLAGS = NODYNSORT; };
 755  763          atomic_add_ptr_nv       { FLAGS = NODYNSORT; };
 756  764          atomic_add_short        { FLAGS = NODYNSORT; };
 757  765          atomic_add_short_nv     { FLAGS = NODYNSORT; };
 758  766          atomic_and_16;
 759  767          atomic_and_16_nv;
 760  768          atomic_and_32_nv;
 761  769          atomic_and_64;
 762  770          atomic_and_64_nv;
 763  771          atomic_and_8;
 764  772          atomic_and_8_nv;
 765  773          atomic_and_uchar        { FLAGS = NODYNSORT; };
 766  774          atomic_and_uchar_nv     { FLAGS = NODYNSORT; };
 767  775          atomic_and_uint_nv      { FLAGS = NODYNSORT; };
 768  776          atomic_and_ulong        { FLAGS = NODYNSORT; };
 769  777          atomic_and_ulong_nv     { FLAGS = NODYNSORT; };
 770  778          atomic_and_ushort       { FLAGS = NODYNSORT; };
 771  779          atomic_and_ushort_nv    { FLAGS = NODYNSORT; };
 772  780          atomic_cas_16;
 773  781          atomic_cas_32;
 774  782          atomic_cas_64;
 775  783          atomic_cas_8;
 776  784          atomic_cas_ptr          { FLAGS = NODYNSORT; };
 777  785          atomic_cas_uchar        { FLAGS = NODYNSORT; };
 778  786          atomic_cas_uint         { FLAGS = NODYNSORT; };
 779  787          atomic_cas_ulong        { FLAGS = NODYNSORT; };
 780  788          atomic_cas_ushort       { FLAGS = NODYNSORT; };
 781  789          atomic_clear_long_excl  { FLAGS = NODYNSORT; };
 782  790          atomic_dec_16;
 783  791          atomic_dec_16_nv;
 784  792          atomic_dec_32;
 785  793          atomic_dec_32_nv;
 786  794          atomic_dec_64;
 787  795          atomic_dec_64_nv;
 788  796          atomic_dec_8;
 789  797          atomic_dec_8_nv;
 790  798          atomic_dec_uchar        { FLAGS = NODYNSORT; };
 791  799          atomic_dec_uchar_nv     { FLAGS = NODYNSORT; };
 792  800          atomic_dec_uint         { FLAGS = NODYNSORT; };
 793  801          atomic_dec_uint_nv      { FLAGS = NODYNSORT; };
 794  802          atomic_dec_ulong        { FLAGS = NODYNSORT; };
 795  803          atomic_dec_ulong_nv     { FLAGS = NODYNSORT; };
 796  804          atomic_dec_ushort       { FLAGS = NODYNSORT; };
 797  805          atomic_dec_ushort_nv    { FLAGS = NODYNSORT; };
 798  806          atomic_inc_16;
 799  807          atomic_inc_16_nv;
 800  808          atomic_inc_32;
 801  809          atomic_inc_32_nv;
 802  810          atomic_inc_64;
 803  811          atomic_inc_64_nv;
 804  812          atomic_inc_8;
 805  813          atomic_inc_8_nv;
 806  814          atomic_inc_uchar        { FLAGS = NODYNSORT; };
 807  815          atomic_inc_uchar_nv     { FLAGS = NODYNSORT; };
 808  816          atomic_inc_uint         { FLAGS = NODYNSORT; };
 809  817          atomic_inc_uint_nv      { FLAGS = NODYNSORT; };
 810  818          atomic_inc_ulong        { FLAGS = NODYNSORT; };
 811  819          atomic_inc_ulong_nv     { FLAGS = NODYNSORT; };
 812  820          atomic_inc_ushort       { FLAGS = NODYNSORT; };
 813  821          atomic_inc_ushort_nv    { FLAGS = NODYNSORT; };
 814  822          atomic_or_16;
 815  823          atomic_or_16_nv;
 816  824          atomic_or_32_nv;
 817  825          atomic_or_64;
 818  826          atomic_or_64_nv;
 819  827          atomic_or_8;
 820  828          atomic_or_8_nv;
 821  829          atomic_or_uchar         { FLAGS = NODYNSORT; };
 822  830          atomic_or_uchar_nv      { FLAGS = NODYNSORT; };
 823  831          atomic_or_uint_nv       { FLAGS = NODYNSORT; };
 824  832          atomic_or_ulong         { FLAGS = NODYNSORT; };
 825  833          atomic_or_ulong_nv      { FLAGS = NODYNSORT; };
 826  834          atomic_or_ushort        { FLAGS = NODYNSORT; };
 827  835          atomic_or_ushort_nv     { FLAGS = NODYNSORT; };
 828  836          atomic_set_long_excl    { FLAGS = NODYNSORT; };
 829  837          atomic_swap_16;
 830  838          atomic_swap_32;
 831  839          atomic_swap_64;
 832  840          atomic_swap_8;
 833  841          atomic_swap_ptr         { FLAGS = NODYNSORT; };
 834  842          atomic_swap_uchar       { FLAGS = NODYNSORT; };
 835  843          atomic_swap_uint        { FLAGS = NODYNSORT; };
 836  844          atomic_swap_ulong       { FLAGS = NODYNSORT; };
 837  845          atomic_swap_ushort      { FLAGS = NODYNSORT; };
 838  846          membar_consumer;
 839  847          membar_enter;
 840  848          membar_exit;
 841  849          membar_producer;
 842  850  
 843  851  $if _ELF32
 844  852          enable_extended_FILE_stdio;
 845  853  $endif
 846  854  
 847  855  $if i386
 848  856          # Note: atomic_[and,dec,inc,or]_64_nv are also defined above. Here,
 849  857          # we add the NODYNSORT attribute to them. On this platform, they are
 850  858          # aliases for the non-_nv versions. If that is changed, these lines
 851  859          # should be removed.
 852  860          atomic_and_64_nv        { FLAGS = NODYNSORT; };
 853  861          atomic_dec_64_nv        { FLAGS = NODYNSORT; };
 854  862          atomic_inc_64_nv        { FLAGS = NODYNSORT; };
 855  863          atomic_or_64_nv         { FLAGS = NODYNSORT; };
 856  864  $endif
 857  865  $if _sparc
 858  866          # Note: atomic_OP_WIDTH_nv symbols are also defined above. Here,
 859  867          # we add the NODYNSORT attribute to them. On this platform, they are
 860  868          # aliases for the non-_nv versions. If that is changed, these lines
 861  869          # should be removed.
 862  870          atomic_add_8_nv         { FLAGS = NODYNSORT; };
 863  871          atomic_and_8_nv         { FLAGS = NODYNSORT; };
 864  872          atomic_and_16_nv        { FLAGS = NODYNSORT; };
 865  873          atomic_and_32_nv        { FLAGS = NODYNSORT; };
 866  874          atomic_and_64_nv        { FLAGS = NODYNSORT; };
 867  875          atomic_dec_8_nv         { FLAGS = NODYNSORT; };
 868  876          atomic_dec_16_nv        { FLAGS = NODYNSORT; };
 869  877          atomic_dec_32_nv        { FLAGS = NODYNSORT; };
 870  878          atomic_dec_64_nv        { FLAGS = NODYNSORT; };
 871  879          atomic_inc_8_nv         { FLAGS = NODYNSORT; };
 872  880          atomic_inc_16_nv        { FLAGS = NODYNSORT; };
 873  881          atomic_inc_32_nv        { FLAGS = NODYNSORT; };
 874  882          atomic_inc_64_nv        { FLAGS = NODYNSORT; };
 875  883          atomic_or_8_nv          { FLAGS = NODYNSORT; };
 876  884          atomic_or_16_nv         { FLAGS = NODYNSORT; };
 877  885          atomic_or_32_nv         { FLAGS = NODYNSORT; };
 878  886          atomic_or_64_nv         { FLAGS = NODYNSORT; };
 879  887  $endif
 880  888  } SUNW_1.22;
 881  889  
 882  890  SYMBOL_VERSION SUNW_1.22 {      # SunOS 5.10 (Solaris 10)
 883  891      global:
 884  892  $if _ELF32
 885  893          dladdr          { TYPE = FUNCTION; FILTER = /usr/lib/ld.so.1; };
 886  894          dladdr1         { TYPE = FUNCTION; FILTER = /usr/lib/ld.so.1; };
 887  895          dlclose         { TYPE = FUNCTION; FILTER = /usr/lib/ld.so.1; };
 888  896          dldump          { TYPE = FUNCTION; FILTER = /usr/lib/ld.so.1; };
 889  897          dlerror         { TYPE = FUNCTION; FILTER = /usr/lib/ld.so.1; };
 890  898          dlinfo          { TYPE = FUNCTION; FILTER = /usr/lib/ld.so.1; };
 891  899          dlmopen         { TYPE = FUNCTION; FILTER = /usr/lib/ld.so.1; };
 892  900          dlopen          { TYPE = FUNCTION; FILTER = /usr/lib/ld.so.1; };
 893  901          dlsym           { TYPE = FUNCTION; FILTER = /usr/lib/ld.so.1; };
 894  902  $elif sparcv9
 895  903          dladdr          { TYPE = FUNCTION; FILTER = /usr/lib/sparcv9/ld.so.1; };
 896  904          dladdr1         { TYPE = FUNCTION; FILTER = /usr/lib/sparcv9/ld.so.1; };
 897  905          dlclose         { TYPE = FUNCTION; FILTER = /usr/lib/sparcv9/ld.so.1; };
 898  906          dldump          { TYPE = FUNCTION; FILTER = /usr/lib/sparcv9/ld.so.1; };
 899  907          dlerror         { TYPE = FUNCTION; FILTER = /usr/lib/sparcv9/ld.so.1; };
 900  908          dlinfo          { TYPE = FUNCTION; FILTER = /usr/lib/sparcv9/ld.so.1; };
 901  909          dlmopen         { TYPE = FUNCTION; FILTER = /usr/lib/sparcv9/ld.so.1; };
 902  910          dlopen          { TYPE = FUNCTION; FILTER = /usr/lib/sparcv9/ld.so.1; };
 903  911          dlsym           { TYPE = FUNCTION; FILTER = /usr/lib/sparcv9/ld.so.1; };
 904  912  $elif amd64
 905  913          dladdr          { TYPE = FUNCTION; FILTER = /usr/lib/amd64/ld.so.1; };
 906  914          dladdr1         { TYPE = FUNCTION; FILTER = /usr/lib/amd64/ld.so.1; };
 907  915          dlamd64getunwind        {
 908  916                                    TYPE = FUNCTION;
 909  917                                    FILTER = /usr/lib/amd64/ld.so.1;
 910  918                                  };
 911  919          dlclose         { TYPE = FUNCTION; FILTER = /usr/lib/amd64/ld.so.1; };
 912  920          dldump          { TYPE = FUNCTION; FILTER = /usr/lib/amd64/ld.so.1; };
 913  921          dlerror         { TYPE = FUNCTION; FILTER = /usr/lib/amd64/ld.so.1; };
 914  922          dlinfo          { TYPE = FUNCTION; FILTER = /usr/lib/amd64/ld.so.1; };
 915  923          dlmopen         { TYPE = FUNCTION; FILTER = /usr/lib/amd64/ld.so.1; };
 916  924          dlopen          { TYPE = FUNCTION; FILTER = /usr/lib/amd64/ld.so.1; };
 917  925          dlsym           { TYPE = FUNCTION; FILTER = /usr/lib/amd64/ld.so.1; };
 918  926  $else
 919  927  $error unknown platform
 920  928  $endif
 921  929  
 922  930      protected:
 923  931          alphasort;
 924  932          _alphasort;
 925  933          atomic_add_16;
 926  934          atomic_add_16_nv;
 927  935          atomic_add_32;
 928  936          atomic_add_32_nv;
 929  937          atomic_add_64;
 930  938          atomic_add_64_nv;
 931  939          atomic_add_long                 { FLAGS = NODYNSORT; };
 932  940          atomic_add_long_nv              { FLAGS = NODYNSORT; };
 933  941          atomic_and_32;
 934  942          atomic_and_uint                 { FLAGS = NODYNSORT; };
 935  943          atomic_or_32;
 936  944          atomic_or_uint                  { FLAGS = NODYNSORT; };
 937  945          _Exit;
 938  946          getisax;
 939  947          _getisax;
 940  948          getopt_clip;
 941  949          _getopt_clip;
 942  950          getopt_long;
 943  951          _getopt_long;
 944  952          getopt_long_only;
 945  953          _getopt_long_only;
 946  954          getpeerucred;
 947  955          _getpeerucred;
 948  956          getpflags;
 949  957          _getpflags;
 950  958          getppriv;
 951  959          _getppriv;
 952  960          getprivimplinfo;
 953  961          _getprivimplinfo;
 954  962          getzoneid;
 955  963          getzoneidbyname;
 956  964          getzonenamebyid;
 957  965          imaxabs;
 958  966          imaxdiv;
 959  967          isblank;
 960  968          iswblank;
 961  969          port_alert;
 962  970          port_associate;
 963  971          port_create;
 964  972          port_dissociate;
 965  973          port_get;
 966  974          port_getn;
 967  975          port_send;
 968  976          port_sendn;
 969  977          posix_openpt;
 970  978          posix_spawn;
 971  979          posix_spawnattr_destroy;
 972  980          posix_spawnattr_getflags;
 973  981          posix_spawnattr_getpgroup;
 974  982          posix_spawnattr_getschedparam;
 975  983          posix_spawnattr_getschedpolicy;
 976  984          posix_spawnattr_getsigdefault;
 977  985          posix_spawnattr_getsigmask;
 978  986          posix_spawnattr_init;
 979  987          posix_spawnattr_setflags;
 980  988          posix_spawnattr_setpgroup;
 981  989          posix_spawnattr_setschedparam;
 982  990          posix_spawnattr_setschedpolicy;
 983  991          posix_spawnattr_setsigdefault;
 984  992          posix_spawnattr_setsigmask;
 985  993          posix_spawn_file_actions_addclose;
 986  994          posix_spawn_file_actions_adddup2;
 987  995          posix_spawn_file_actions_addopen;
 988  996          posix_spawn_file_actions_destroy;
 989  997          posix_spawn_file_actions_init;
 990  998          posix_spawnp;
 991  999          priv_addset;
 992 1000          _priv_addset;
 993 1001          priv_allocset;
 994 1002          _priv_allocset;
 995 1003          priv_copyset;
 996 1004          _priv_copyset;
 997 1005          priv_delset;
 998 1006          _priv_delset;
 999 1007          priv_emptyset;
1000 1008          _priv_emptyset;
1001 1009          priv_fillset;
1002 1010          _priv_fillset;
1003 1011          __priv_free_info;
1004 1012          priv_freeset;
1005 1013          _priv_freeset;
1006 1014          priv_getbyname;
1007 1015          _priv_getbyname;
1008 1016          __priv_getbyname;
1009 1017          priv_getbynum;
1010 1018          _priv_getbynum;
1011 1019          __priv_getbynum;
1012 1020          __priv_getdata;
1013 1021          priv_getsetbyname;
1014 1022          _priv_getsetbyname;
1015 1023          __priv_getsetbyname;
1016 1024          priv_getsetbynum;
1017 1025          _priv_getsetbynum;
1018 1026          __priv_getsetbynum;
1019 1027          priv_gettext;
1020 1028          _priv_gettext;
1021 1029          priv_ineffect;
1022 1030          _priv_ineffect;
1023 1031          priv_intersect;
1024 1032          _priv_intersect;
1025 1033          priv_inverse;
1026 1034          _priv_inverse;
1027 1035          priv_isemptyset;
1028 1036          _priv_isemptyset;
1029 1037          priv_isequalset;
1030 1038          _priv_isequalset;
1031 1039          priv_isfullset;
1032 1040          _priv_isfullset;
1033 1041          priv_ismember;
1034 1042          _priv_ismember;
1035 1043          priv_issubset;
1036 1044          _priv_issubset;
1037 1045          __priv_parse_info;
1038 1046          priv_set;
1039 1047          _priv_set;
1040 1048          priv_set_to_str;
1041 1049          _priv_set_to_str;
1042 1050          __priv_set_to_str;
1043 1051          priv_str_to_set;
1044 1052          _priv_str_to_set;
1045 1053          priv_union;
1046 1054          _priv_union;
1047 1055          pselect;
1048 1056          pthread_attr_getstack;
1049 1057          pthread_attr_setstack;
1050 1058          pthread_barrierattr_destroy;
1051 1059          pthread_barrierattr_getpshared;
1052 1060          pthread_barrierattr_init;
1053 1061          pthread_barrierattr_setpshared;
1054 1062          pthread_barrier_destroy;
1055 1063          pthread_barrier_init;
1056 1064          pthread_barrier_wait;
1057 1065          pthread_condattr_getclock;
1058 1066          pthread_condattr_setclock;
1059 1067          pthread_mutexattr_getrobust_np  { FLAGS = NODYNSORT; };
1060 1068          pthread_mutexattr_setrobust_np  { FLAGS = NODYNSORT; };
1061 1069          pthread_mutex_consistent_np     { FLAGS = NODYNSORT; };
1062 1070          pthread_mutex_reltimedlock_np;
1063 1071          pthread_mutex_timedlock;
1064 1072          pthread_rwlock_reltimedrdlock_np;
1065 1073          pthread_rwlock_reltimedwrlock_np;
1066 1074          pthread_rwlock_timedrdlock;
1067 1075          pthread_rwlock_timedwrlock;
1068 1076          pthread_setschedprio;
1069 1077          pthread_spin_destroy;
1070 1078          pthread_spin_init;
1071 1079          pthread_spin_lock;
1072 1080          pthread_spin_trylock;
1073 1081          pthread_spin_unlock;
1074 1082          rctlblk_set_recipient_pid;
1075 1083          scandir;
1076 1084          _scandir;
1077 1085          schedctl_exit;
1078 1086          schedctl_init;
1079 1087          schedctl_lookup;
1080 1088          sema_reltimedwait;
1081 1089          sema_timedwait;
1082 1090          setenv;
1083 1091          setpflags;
1084 1092          _setpflags;
1085 1093          setppriv;
1086 1094          _setppriv;
1087 1095          strerror_r;
1088 1096          strtof;
1089 1097          strtoimax;
1090 1098          strtold;
1091 1099          strtoumax;
1092 1100          ucred_free;
1093 1101          _ucred_free;
1094 1102          ucred_get;
1095 1103          _ucred_get;
1096 1104          ucred_getegid;
1097 1105          _ucred_getegid;
1098 1106          ucred_geteuid;
1099 1107          _ucred_geteuid;
1100 1108          ucred_getgroups;
1101 1109          _ucred_getgroups;
1102 1110          ucred_getpflags;
1103 1111          _ucred_getpflags;
1104 1112          ucred_getpid;
1105 1113          _ucred_getpid;
1106 1114          ucred_getprivset;
1107 1115          _ucred_getprivset;
1108 1116          ucred_getprojid;
1109 1117          _ucred_getprojid;
1110 1118          ucred_getrgid;
1111 1119          _ucred_getrgid;
1112 1120          ucred_getruid;
1113 1121          _ucred_getruid;
1114 1122          ucred_getsgid;
1115 1123          _ucred_getsgid;
1116 1124          ucred_getsuid;
1117 1125          _ucred_getsuid;
1118 1126          ucred_getzoneid;
1119 1127          _ucred_getzoneid;
1120 1128          ucred_size;
1121 1129          _ucred_size;
1122 1130          unsetenv;
1123 1131          wcstof;
1124 1132          wcstoimax;
1125 1133          wcstold;
1126 1134          wcstoll;
1127 1135          wcstoull;
1128 1136          wcstoumax;
1129 1137  
1130 1138  $if lf64
1131 1139          alphasort64;
1132 1140          _alphasort64;
1133 1141          pselect_large_fdset;
1134 1142          scandir64;
1135 1143          _scandir64;
1136 1144  $endif
1137 1145  
1138 1146  $if _ELF64
1139 1147          walkcontext;
1140 1148  $endif
1141 1149  
1142 1150  $if _sparc
1143 1151          # Note: atomic_add_[16,32,64]_nv are also defined above. Here, we add
1144 1152          # the NODYNSORT attribute to them. On this platform, they are aliases
1145 1153          # for the non-_nv versions. If that is changed, these lines should be
1146 1154          # removed.
1147 1155          atomic_add_16_nv                { FLAGS = NODYNSORT; };
1148 1156          atomic_add_32_nv                { FLAGS = NODYNSORT; };
1149 1157          atomic_add_64_nv                { FLAGS = NODYNSORT; };
1150 1158  $endif
1151 1159  
1152 1160  $if i386
1153 1161          # Note: atomic_add_64_nv is also defined above. Here, we add the
1154 1162          # NODYNSORT attribute to it. On this platform, it is an aliases for
1155 1163          # atomic_add_64. If that is changed, this line should be removed.
1156 1164          atomic_add_64_nv                { FLAGS = NODYNSORT; };
1157 1165  $endif
1158 1166  
1159 1167  $if amd64
1160 1168          # Exception unwind APIs required by the amd64 ABI
1161 1169          _SUNW_Unwind_DeleteException;
1162 1170          _SUNW_Unwind_ForcedUnwind;
1163 1171          _SUNW_Unwind_GetCFA;
1164 1172          _SUNW_Unwind_GetGR;
1165 1173          _SUNW_Unwind_GetIP;
1166 1174          _SUNW_Unwind_GetLanguageSpecificData;
1167 1175          _SUNW_Unwind_GetRegionStart;
1168 1176          _SUNW_Unwind_RaiseException;
1169 1177          _SUNW_Unwind_Resume;
1170 1178          _SUNW_Unwind_SetGR;
1171 1179          _SUNW_Unwind_SetIP;
1172 1180          _UA_CLEANUP_PHASE               {
1173 1181                                            ASSERT = {
1174 1182                                                    TYPE = OBJECT;
1175 1183                                                    SIZE = 4;
1176 1184                                                  };
1177 1185                                          };
1178 1186          _UA_FORCE_UNWIND                {
1179 1187                                            ASSERT = {
1180 1188                                                    TYPE = OBJECT;
1181 1189                                                    SIZE = 4;
1182 1190                                                  };
1183 1191                                          };
1184 1192          _UA_HANDLER_FRAME               {
1185 1193                                            ASSERT = {
1186 1194                                                    TYPE = OBJECT;
1187 1195                                                    SIZE = 4;
1188 1196                                                  };
1189 1197                                          };
1190 1198          _UA_SEARCH_PHASE                {
1191 1199                                            ASSERT = {
1192 1200                                                    TYPE = OBJECT;
1193 1201                                                    SIZE = 4;
1194 1202                                                  };
1195 1203                                          };
1196 1204          _Unwind_DeleteException;
1197 1205          _Unwind_ForcedUnwind;
1198 1206          _Unwind_GetCFA;
1199 1207          _Unwind_GetGR;
1200 1208          _Unwind_GetIP;
1201 1209          _Unwind_GetLanguageSpecificData;
1202 1210          _Unwind_GetRegionStart;
1203 1211          _Unwind_RaiseException;
1204 1212          _Unwind_Resume;
1205 1213          _Unwind_SetGR;
1206 1214          _Unwind_SetIP;
1207 1215  $endif
1208 1216  } SUNW_1.21.3;
1209 1217  
1210 1218  SYMBOL_VERSION SUNW_1.21.3 {    # SunOS 5.9 (Solaris 9) patch additions
1211 1219      protected:
1212 1220          forkall;
1213 1221  } SUNW_1.21.2;
1214 1222  
1215 1223  SYMBOL_VERSION SUNW_1.21.2 {    # SunOS 5.9 (Solaris 9) patch additions
1216 1224      protected:
1217 1225          getustack;
1218 1226          _getustack;
1219 1227          setustack;
1220 1228          _setustack;
1221 1229          stack_getbounds;
1222 1230          _stack_getbounds;
1223 1231          _stack_grow;
1224 1232          stack_inbounds;
1225 1233          _stack_inbounds;
1226 1234          stack_setbounds;
1227 1235          _stack_setbounds;
1228 1236          stack_violation;
1229 1237          _stack_violation;
1230 1238  
1231 1239  $if _sparc
1232 1240          __makecontext_v2;
1233 1241          ___makecontext_v2;
1234 1242  $endif
1235 1243  } SUNW_1.21.1;
1236 1244  
1237 1245  SYMBOL_VERSION SUNW_1.21.1 {    # SunOS 5.9 (Solaris 9) patch additions
1238 1246      protected:
1239 1247          crypt_gensalt;
1240 1248  } SUNW_1.21;
1241 1249  
1242 1250  SYMBOL_VERSION SUNW_1.21 {      # SunOS 5.9 (Solaris 9)
1243 1251      protected:
1244 1252          attropen;
1245 1253          _attropen;
1246 1254          bind_textdomain_codeset;
1247 1255          closefrom;
1248 1256          _closefrom;
1249 1257          cond_reltimedwait;
1250 1258          dcngettext;
1251 1259          dngettext;
1252 1260          fchownat;
1253 1261          _fchownat;
1254 1262          fdopendir;
1255 1263          _fdopendir;
1256 1264          fdwalk;
1257 1265          _fdwalk;
1258 1266          fstatat;
1259 1267          _fstatat;
1260 1268          futimesat;
1261 1269          _futimesat;
1262 1270          getcpuid;
1263 1271          _getcpuid;
1264 1272          gethomelgroup;
1265 1273          _gethomelgroup  { FLAGS = NODYNSORT; };
1266 1274          getpagesizes;
1267 1275          getrctl;
1268 1276          _getrctl;
1269 1277          issetugid;
1270 1278          _issetugid;
1271 1279          _lwp_cond_reltimedwait;
1272 1280          meminfo;
1273 1281          _meminfo;
1274 1282          ngettext;
1275 1283          openat;
1276 1284          _openat;
1277 1285          printstack;
1278 1286          priocntl;
1279 1287          priocntlset;
1280 1288          pset_getattr;
1281 1289          pset_getloadavg;
1282 1290          pset_list;
1283 1291          pset_setattr;
1284 1292          pthread_cond_reltimedwait_np;
1285 1293          rctlblk_get_enforced_value;
1286 1294          rctlblk_get_firing_time;
1287 1295          rctlblk_get_global_action;
1288 1296          rctlblk_get_global_flags;
1289 1297          rctlblk_get_local_action;
1290 1298          rctlblk_get_local_flags;
1291 1299          rctlblk_get_privilege;
1292 1300          rctlblk_get_recipient_pid;
1293 1301          rctlblk_get_value;
1294 1302          rctlblk_set_local_action;
1295 1303          rctlblk_set_local_flags;
1296 1304          rctlblk_set_privilege;
1297 1305          rctlblk_set_value;
1298 1306          rctlblk_size;
1299 1307          rctl_walk;
1300 1308          renameat;
1301 1309          setrctl;
1302 1310          _setrctl;
1303 1311          unlinkat;
1304 1312          _unlinkat;
1305 1313          vfscanf;
1306 1314          _vfscanf;
1307 1315          vfwscanf;
1308 1316          vscanf;
1309 1317          _vscanf;
1310 1318          vsscanf;
1311 1319          _vsscanf;
1312 1320          vswscanf;
1313 1321          vwscanf;
1314 1322  
1315 1323  $if _ELF32
1316 1324          walkcontext;
1317 1325  $endif
1318 1326  
1319 1327  $if lf64
1320 1328          attropen64;
1321 1329          _attropen64;
1322 1330          fstatat64;
1323 1331          _fstatat64;
1324 1332          openat64;
1325 1333          _openat64;
1326 1334  $endif
1327 1335  } SUNW_1.20.4;
1328 1336  
1329 1337  SYMBOL_VERSION SUNW_1.20.4 {    # SunOS 5.8 (Solaris 8) patch additions
1330 1338      protected:
1331 1339          semtimedop;
1332 1340          _semtimedop;
1333 1341  } SUNW_1.20.1;
1334 1342  
1335 1343  SYMBOL_VERSION SUNW_1.20.1 {    # SunOS 5.8 (Solaris 8) patch additions
1336 1344      protected:
1337 1345          getacct;
1338 1346          _getacct;
1339 1347          getprojid;
1340 1348          _getprojid;
1341 1349          gettaskid;
1342 1350          _gettaskid;
1343 1351          msgids;
1344 1352          _msgids;
1345 1353          msgsnap;
1346 1354          _msgsnap;
1347 1355          putacct;
1348 1356          _putacct;
1349 1357          semids;
1350 1358          _semids;
1351 1359          settaskid;
1352 1360          _settaskid;
1353 1361          shmids;
1354 1362          _shmids;
1355 1363          wracct;
1356 1364          _wracct;
1357 1365  } SUNW_1.20;
1358 1366  
1359 1367  SYMBOL_VERSION SUNW_1.20 {      # SunOS 5.8 (Solaris 8)
1360 1368      protected:
1361 1369          getextmntent;
1362 1370          resetmnttab;
1363 1371  } SUNW_1.19;
1364 1372  
1365 1373  SYMBOL_VERSION SUNW_1.19 {
1366 1374      protected:
1367 1375          strlcat;
1368 1376          strlcpy;
1369 1377          umount2;
1370 1378          _umount2;
1371 1379  } SUNW_1.18.1;
1372 1380  
1373 1381  SYMBOL_VERSION SUNW_1.18.1 {
1374 1382      protected:
1375 1383          __fsetlocking;
1376 1384  } SUNW_1.18;
1377 1385  
1378 1386  SYMBOL_VERSION SUNW_1.18 {      # SunOS 5.7 (Solaris 7)
1379 1387      protected:
1380 1388          btowc;
1381 1389          __fbufsize;
1382 1390          __flbf;
1383 1391          _flushlbf;
1384 1392          __fpending;
1385 1393          __fpurge;
1386 1394          __freadable;
1387 1395          __freading;
1388 1396          fwide;
1389 1397          fwprintf;
1390 1398          __fwritable;
1391 1399          __fwriting;
1392 1400          fwscanf;
1393 1401          getloadavg;
1394 1402          isaexec;
1395 1403          mbrlen;
1396 1404          mbrtowc;
1397 1405          mbsinit;
1398 1406          mbsrtowcs;
1399 1407          pcsample;
1400 1408          pthread_attr_getguardsize;
1401 1409          pthread_attr_setguardsize;
1402 1410          pthread_getconcurrency;
1403 1411          pthread_mutexattr_gettype;
1404 1412          pthread_mutexattr_settype;
1405 1413          pthread_rwlockattr_destroy;
1406 1414          pthread_rwlockattr_getpshared;
1407 1415          pthread_rwlockattr_init;
1408 1416          pthread_rwlockattr_setpshared;
1409 1417          pthread_rwlock_destroy;
1410 1418          pthread_rwlock_init;
1411 1419          pthread_rwlock_rdlock;
1412 1420          pthread_rwlock_tryrdlock;
1413 1421          pthread_rwlock_trywrlock;
1414 1422          pthread_rwlock_unlock;
1415 1423          pthread_rwlock_wrlock;
1416 1424          pthread_setconcurrency;
1417 1425          swprintf;
1418 1426          swscanf;
1419 1427          __sysconf_xpg5;
1420 1428          vfwprintf;
1421 1429          vswprintf;
1422 1430          vwprintf;
1423 1431          wcrtomb;
1424 1432          wcsrtombs;
1425 1433          wcsstr;
1426 1434          wctob;
1427 1435          wmemchr;
1428 1436          wmemcmp;
1429 1437          wmemcpy;
1430 1438          wmemmove;
1431 1439          wmemset;
1432 1440          wprintf;
1433 1441          wscanf;
1434 1442  
1435 1443  $if _ELF32
1436 1444          select_large_fdset;
1437 1445  $endif
1438 1446  } SUNW_1.17;
1439 1447  
1440 1448  # The empty versions SUNW_1.2 through SUNW_1.17 must be preserved because
1441 1449  # applications built on Solaris 2.6 Beta (when they did contain symbols)
1442 1450  # may depend on them.  All symbol content for SunOS 5.6 is now in SUNW_1.1
1443 1451  
1444 1452  SYMBOL_VERSION SUNW_1.17 {
1445 1453      protected:
1446 1454          SUNW_1.17;
1447 1455  } SUNW_1.16;
1448 1456  
1449 1457  SYMBOL_VERSION SUNW_1.16 {
1450 1458      protected:
1451 1459          SUNW_1.16;
1452 1460  } SUNW_1.15;
1453 1461  
1454 1462  SYMBOL_VERSION SUNW_1.15 {
1455 1463      protected:
1456 1464          SUNW_1.15;
1457 1465  } SUNW_1.14;
1458 1466  
1459 1467  SYMBOL_VERSION SUNW_1.14 {
1460 1468      protected:
1461 1469          SUNW_1.14;
1462 1470  } SUNW_1.13;
1463 1471  
1464 1472  SYMBOL_VERSION SUNW_1.13 {
1465 1473      protected:
1466 1474          SUNW_1.13;
1467 1475  } SUNW_1.12;
1468 1476  
1469 1477  SYMBOL_VERSION SUNW_1.12 {
1470 1478      protected:
1471 1479          SUNW_1.12;
1472 1480  } SUNW_1.11;
1473 1481  
1474 1482  SYMBOL_VERSION SUNW_1.11 {
1475 1483      protected:
1476 1484          SUNW_1.11;
1477 1485  } SUNW_1.10;
1478 1486  
1479 1487  SYMBOL_VERSION SUNW_1.10 {
1480 1488      protected:
1481 1489          SUNW_1.10;
1482 1490  } SUNW_1.9;
1483 1491  
1484 1492  SYMBOL_VERSION SUNW_1.9 {
1485 1493      protected:
1486 1494          SUNW_1.9;
1487 1495  } SUNW_1.8;
1488 1496  
1489 1497  SYMBOL_VERSION SUNW_1.8 {
1490 1498      protected:
1491 1499          SUNW_1.8;
1492 1500  } SUNW_1.7;
1493 1501  
1494 1502  SYMBOL_VERSION SUNW_1.7 {
1495 1503      protected:
1496 1504          SUNW_1.7;
1497 1505  } SUNW_1.6;
1498 1506  
1499 1507  SYMBOL_VERSION SUNW_1.6 {
1500 1508      protected:
1501 1509          SUNW_1.6;
1502 1510  } SUNW_1.5;
1503 1511  
1504 1512  SYMBOL_VERSION SUNW_1.5 {
1505 1513      protected:
1506 1514          SUNW_1.5;
1507 1515  } SUNW_1.4;
1508 1516  
1509 1517  SYMBOL_VERSION SUNW_1.4 {
1510 1518      protected:
1511 1519          SUNW_1.4;
1512 1520  } SUNW_1.3;
1513 1521  
1514 1522  SYMBOL_VERSION SUNW_1.3 {
1515 1523      protected:
1516 1524          SUNW_1.3;
1517 1525  } SUNW_1.2;
1518 1526  
1519 1527  SYMBOL_VERSION SUNW_1.2 {
1520 1528      protected:
1521 1529          SUNW_1.2;
1522 1530  } SUNW_1.1;
1523 1531  
1524 1532  SYMBOL_VERSION SUNW_1.1 {       # SunOS 5.6 (Solaris 2.6)
1525 1533      global:
1526 1534          __loc1          {
1527 1535                            ASSERT = {
1528 1536                                    TYPE = OBJECT;
1529 1537                                    SIZE = addrsize;
1530 1538                                  };
1531 1539                          };
1532 1540      protected:
1533 1541          basename;
1534 1542          bindtextdomain;
1535 1543          bsd_signal;
1536 1544          dbm_clearerr;
1537 1545          dbm_error;
1538 1546          dcgettext;
1539 1547          dgettext;
1540 1548          directio;
1541 1549          dirname;
1542 1550          endusershell;
1543 1551          _exithandle;
1544 1552          fgetwc;
1545 1553          fgetws;
1546 1554          fpgetround;
1547 1555          fpsetround;
1548 1556          fputwc;
1549 1557          fputws;
1550 1558          fseeko;
1551 1559          ftello;
1552 1560          ftrylockfile;
1553 1561          getexecname;
1554 1562          _getexecname;
1555 1563          getpassphrase;
1556 1564          gettext;
1557 1565          getusershell;
1558 1566          getwc;
1559 1567          getwchar;
1560 1568          getws;
1561 1569          isenglish;
1562 1570          isideogram;
1563 1571          isnumber;
1564 1572          isphonogram;
1565 1573          isspecial;
1566 1574          iswalnum;
1567 1575          iswalpha;
1568 1576          iswcntrl;
1569 1577          iswctype;
1570 1578          iswdigit;
1571 1579          iswgraph;
1572 1580          iswlower;
1573 1581          iswprint;
1574 1582          iswpunct;
1575 1583          iswspace;
1576 1584          iswupper;
1577 1585          iswxdigit;
1578 1586          ____loc1;
1579 1587          _longjmp;
1580 1588          _lwp_sema_trywait;
1581 1589          ntp_adjtime;
1582 1590          _ntp_adjtime;
1583 1591          ntp_gettime;
1584 1592          _ntp_gettime;
1585 1593          __posix_asctime_r;
1586 1594          __posix_ctime_r;
1587 1595          __posix_getgrgid_r;
1588 1596          __posix_getgrnam_r;
1589 1597          __posix_getlogin_r;
1590 1598          __posix_getpwnam_r;
1591 1599          __posix_getpwuid_r;
1592 1600          __posix_sigwait;
1593 1601          __posix_ttyname_r;
1594 1602          pset_assign;
1595 1603          pset_bind;
1596 1604          pset_create;
1597 1605          pset_destroy;
1598 1606          pset_info;
1599 1607          pthread_atfork;
1600 1608          pthread_attr_destroy;
1601 1609          pthread_attr_getdetachstate;
1602 1610          pthread_attr_getinheritsched;
1603 1611          pthread_attr_getschedparam;
1604 1612          pthread_attr_getschedpolicy;
1605 1613          pthread_attr_getscope;
1606 1614          pthread_attr_getstackaddr;
1607 1615          pthread_attr_getstacksize;
1608 1616          pthread_attr_init;
1609 1617          pthread_attr_setdetachstate;
1610 1618          pthread_attr_setinheritsched;
1611 1619          pthread_attr_setschedparam;
1612 1620          pthread_attr_setschedpolicy;
1613 1621          pthread_attr_setscope;
1614 1622          pthread_attr_setstackaddr;
1615 1623          pthread_attr_setstacksize;
1616 1624          pthread_cancel;
1617 1625          __pthread_cleanup_pop;
1618 1626          __pthread_cleanup_push;
1619 1627          pthread_create;
1620 1628          pthread_detach;
1621 1629          pthread_equal;
1622 1630          pthread_exit;
1623 1631          pthread_getschedparam;
1624 1632          pthread_getspecific;
1625 1633          pthread_join;
1626 1634          pthread_key_create;
1627 1635          pthread_key_delete;
1628 1636          pthread_kill;
1629 1637          pthread_once;
1630 1638          pthread_self;
1631 1639          pthread_setcancelstate;
1632 1640          pthread_setcanceltype;
1633 1641          pthread_setschedparam;
1634 1642          pthread_setspecific;
1635 1643          pthread_sigmask;
1636 1644          pthread_testcancel;
1637 1645          putwc;
1638 1646          putwchar;
1639 1647          putws;
1640 1648          regcmp;
1641 1649          regex;
1642 1650          resolvepath;
1643 1651          _resolvepath;
1644 1652          rwlock_destroy          { FLAGS = NODYNSORT; };
1645 1653          _rwlock_destroy         { FLAGS = NODYNSORT; };
1646 1654          sema_destroy;
1647 1655          _sema_destroy;
1648 1656          _setjmp;
1649 1657          setusershell;
1650 1658          siginterrupt;
1651 1659          sigstack;
1652 1660          snprintf;
1653 1661          strtows;
1654 1662          sync_instruction_memory;
1655 1663          textdomain;
1656 1664          thr_main;
1657 1665          towctrans;
1658 1666          towlower;
1659 1667          towupper;
1660 1668          ungetwc;
1661 1669          vsnprintf;
1662 1670          watoll;
1663 1671          wcscat;
1664 1672          wcschr;
1665 1673          wcscmp;
1666 1674          wcscoll;
1667 1675          wcscpy;
1668 1676          wcscspn;
1669 1677          wcsftime;
1670 1678          wcslen;
1671 1679          wcsncat;
1672 1680          wcsncmp;
1673 1681          wcsncpy;
1674 1682          wcspbrk;
1675 1683          wcsrchr;
1676 1684          wcsspn;
1677 1685          wcstod;
1678 1686          wcstok;
1679 1687          wcstol;
1680 1688          wcstoul;
1681 1689          wcswcs;
1682 1690          wcswidth;
1683 1691          wcsxfrm;
1684 1692          wctrans;
1685 1693          wctype;
1686 1694          wcwidth;
1687 1695          wscasecmp;
1688 1696          wscat;
1689 1697          wschr;
1690 1698          wscmp;
1691 1699          wscol;
1692 1700          wscoll;
1693 1701          wscpy;
1694 1702          wscspn;
1695 1703          wsdup;
1696 1704          wslen;
1697 1705          wsncasecmp;
1698 1706          wsncat;
1699 1707          wsncmp;
1700 1708          wsncpy;
1701 1709          wspbrk;
1702 1710          wsprintf;
1703 1711          wsrchr;
1704 1712          wsscanf;
1705 1713          wsspn;
1706 1714          wstod;
1707 1715          wstok;
1708 1716          wstol;
1709 1717          wstoll;
1710 1718          wstostr;
1711 1719          wsxfrm;
1712 1720          __xpg4_putmsg;
1713 1721          __xpg4_putpmsg;
1714 1722  
1715 1723  $if lf64
1716 1724          creat64;
1717 1725          _creat64;
1718 1726          fgetpos64;
1719 1727          fopen64;
1720 1728          freopen64;
1721 1729          fseeko64;
1722 1730          fsetpos64;
1723 1731          fstat64;
1724 1732          _fstat64;
1725 1733          fstatvfs64;
1726 1734          _fstatvfs64;
1727 1735          ftello64;
1728 1736          ftruncate64;
1729 1737          _ftruncate64;
1730 1738          ftw64;
1731 1739          _ftw64;
1732 1740          getdents64;
1733 1741          _getdents64;
1734 1742          getrlimit64;
1735 1743          _getrlimit64;
1736 1744          lockf64;
1737 1745          _lockf64;
1738 1746          lseek64;
1739 1747          _lseek64;
1740 1748          lstat64;
1741 1749          _lstat64;
1742 1750          mkstemp64;
1743 1751          _mkstemp64;
1744 1752          mmap64;
1745 1753          _mmap64;
1746 1754          nftw64;
1747 1755          _nftw64;
1748 1756          open64;
1749 1757          _open64;
1750 1758          __posix_readdir_r;
1751 1759          pread64;
1752 1760          _pread64;
1753 1761          pwrite64;
1754 1762          _pwrite64;
1755 1763          readdir64;
1756 1764          _readdir64;
1757 1765          readdir64_r;
1758 1766          _readdir64_r;
1759 1767          setrlimit64;
1760 1768          _setrlimit64;
1761 1769          s_fcntl;
1762 1770          _s_fcntl        { FLAGS = NODYNSORT; };
1763 1771          s_ioctl;
1764 1772          stat64;
1765 1773          _stat64;
1766 1774          statvfs64;
1767 1775          _statvfs64;
1768 1776          tell64;
1769 1777          _tell64;
1770 1778          tmpfile64;
1771 1779          truncate64;
1772 1780          _truncate64;
1773 1781          _xftw64;
1774 1782  $endif
1775 1783  
1776 1784  $if _sparc
1777 1785          __flt_rounds;
1778 1786  $endif
1779 1787  } SUNW_0.9;
1780 1788  
1781 1789  SYMBOL_VERSION SUNW_0.9 {       # SunOS 5.5 (Solaris 2.5)
1782 1790      protected:
1783 1791          acl;
1784 1792          bcmp;
1785 1793          bcopy;
1786 1794          bzero;
1787 1795          facl;
1788 1796          ftime;
1789 1797          getdtablesize;
1790 1798          gethostid;
1791 1799          gethostname;
1792 1800          getpagesize;
1793 1801          getpriority;
1794 1802          getrusage;
1795 1803          getwd;
1796 1804          index;
1797 1805          initstate;
1798 1806          killpg;
1799 1807          _nsc_trydoorcall;
1800 1808          pthread_condattr_destroy;
1801 1809          pthread_condattr_getpshared;
1802 1810          pthread_condattr_init;
1803 1811          pthread_condattr_setpshared;
1804 1812          pthread_cond_broadcast;
1805 1813          pthread_cond_destroy;
1806 1814          pthread_cond_init;
1807 1815          pthread_cond_signal;
1808 1816          pthread_cond_timedwait;
1809 1817          pthread_cond_wait;
1810 1818          pthread_mutexattr_destroy;
1811 1819          pthread_mutexattr_getprioceiling;
1812 1820          pthread_mutexattr_getprotocol;
1813 1821          pthread_mutexattr_getpshared;
1814 1822          pthread_mutexattr_init;
1815 1823          pthread_mutexattr_setprioceiling;
1816 1824          pthread_mutexattr_setprotocol;
1817 1825          pthread_mutexattr_setpshared;
1818 1826          pthread_mutex_destroy;
1819 1827          pthread_mutex_getprioceiling;
1820 1828          pthread_mutex_init;
1821 1829          pthread_mutex_lock;
1822 1830          pthread_mutex_setprioceiling;
1823 1831          pthread_mutex_trylock;
1824 1832          pthread_mutex_unlock;
1825 1833          random;
1826 1834          reboot;
1827 1835          re_comp;
1828 1836          re_exec;
1829 1837          rindex;
1830 1838          setbuffer;
1831 1839          sethostname;
1832 1840          setlinebuf;
1833 1841          setpriority;
1834 1842          setregid;
1835 1843          setreuid;
1836 1844          setstate;
1837 1845          srandom;
1838 1846          thr_min_stack;
1839 1847          thr_stksegment;
1840 1848          ualarm;
1841 1849          usleep;
1842 1850          wait3;
1843 1851          wait4;
1844 1852  } SUNW_0.8;
1845 1853  
1846 1854  SYMBOL_VERSION SUNW_0.8 {       # SunOS 5.4 (Solaris 2.4)
1847 1855      global:
1848 1856          __xpg4          {
1849 1857                            ASSERT = {
1850 1858                                    TYPE = OBJECT;
1851 1859                                    SIZE = 4;
1852 1860                                  };
1853 1861                            FLAGS = NODIRECT;
1854 1862                          };
1855 1863      protected:
1856 1864          addsev;
1857 1865          cond_broadcast  { FLAGS = NODYNSORT; };
1858 1866          cond_destroy    { FLAGS = NODYNSORT; };
1859 1867          cond_init;
1860 1868          cond_signal     { FLAGS = NODYNSORT; };
1861 1869          cond_timedwait;
1862 1870          cond_wait;
1863 1871          confstr;
1864 1872          fnmatch;
1865 1873          _getdate_err_addr;
1866 1874          glob;
1867 1875          globfree;
1868 1876          iconv;
1869 1877          iconv_close;
1870 1878          iconv_open;
1871 1879          lfmt;
1872 1880          mutex_destroy   { FLAGS = NODYNSORT; };
1873 1881          mutex_init;
1874 1882          mutex_lock      { FLAGS = NODYNSORT; };
1875 1883          mutex_trylock   { FLAGS = NODYNSORT; };
1876 1884          mutex_unlock    { FLAGS = NODYNSORT; };
1877 1885          pfmt;
1878 1886          regcomp;
1879 1887          regerror;
1880 1888          regexec;
1881 1889          regfree;
1882 1890          rwlock_init;
1883 1891          rw_rdlock       { FLAGS = NODYNSORT; };
1884 1892          rw_read_held;
1885 1893          rw_tryrdlock    { FLAGS = NODYNSORT; };
1886 1894          rw_trywrlock    { FLAGS = NODYNSORT; };
1887 1895          rw_unlock       { FLAGS = NODYNSORT; };
1888 1896          rw_write_held;
1889 1897          rw_wrlock       { FLAGS = NODYNSORT; };
1890 1898          sema_held;
1891 1899          sema_init;
1892 1900          sema_post;
1893 1901          sema_trywait;
1894 1902          sema_wait;
1895 1903          setcat;
1896 1904          sigfpe;
1897 1905          strfmon;
1898 1906          strptime;
1899 1907          thr_continue;
1900 1908          thr_create;
1901 1909          thr_exit;
1902 1910          thr_getconcurrency;
1903 1911          thr_getprio;
1904 1912          thr_getspecific;
1905 1913          thr_join;
1906 1914          thr_keycreate;
1907 1915          thr_kill;
1908 1916          thr_self        { FLAGS = NODYNSORT; };
1909 1917          thr_setconcurrency;
1910 1918          thr_setprio;
1911 1919          thr_setspecific;
1912 1920          thr_sigsetmask;
1913 1921          thr_suspend;
1914 1922          thr_yield;
1915 1923          vlfmt;
1916 1924          vpfmt;
1917 1925          wordexp;
1918 1926          wordfree;
1919 1927  } SUNW_0.7;
1920 1928  
1921 1929  SYMBOL_VERSION SUNW_0.7 {       # SunOS 5.3 (Solaris 2.3)
1922 1930      global:
1923 1931          altzone                 {
1924 1932                                    ASSERT = {
1925 1933                                            TYPE = OBJECT;
1926 1934                                            SIZE = addrsize;
1927 1935                                          };
1928 1936                                  };
1929 1937          _ctype                  {
1930 1938                                    ASSERT = {
1931 1939                                            BINDING = WEAK;
1932 1940                                            ALIAS = __ctype;
1933 1941                                          };
1934 1942                                  };
1935 1943          isnanf                  { TYPE = FUNCTION; FILTER = libm.so.2; };
1936 1944          lone                    { ASSERT = { TYPE = OBJECT; SIZE = 8; }; };
1937 1945          lten                    { ASSERT = { TYPE = OBJECT; SIZE = 8; }; };
1938 1946          lzero                   { ASSERT = { TYPE = OBJECT; SIZE = 8; }; };
1939 1947          memalign                { FLAGS = NODIRECT; };
1940 1948          modff                   { TYPE = FUNCTION; FILTER = libm.so.2; };
1941 1949          nss_default_finders     {
1942 1950                                    ASSERT = {
1943 1951                                            TYPE = OBJECT;
1944 1952                                            SIZE = addrsize;
1945 1953                                          };
1946 1954                                  };
1947 1955          _sibuf                  {
1948 1956                                    ASSERT = {
1949 1957                                            TYPE = OBJECT;
1950 1958                                            SIZE = 1032;
1951 1959                                          };
1952 1960                                  };
1953 1961          _sobuf                  {
1954 1962                                    ASSERT = {
1955 1963                                            TYPE = OBJECT;
1956 1964                                            SIZE = 1032;
1957 1965                                          };
1958 1966                                  };
1959 1967          _sys_buslist            {
1960 1968                                    ASSERT = {
1961 1969                                            TYPE = OBJECT;
1962 1970                                            SIZE = addrsize[3];
1963 1971                                          };
1964 1972                                  };
1965 1973          _sys_cldlist            {
1966 1974                                    ASSERT = {
1967 1975                                            TYPE = OBJECT;
1968 1976                                            SIZE = addrsize[6];
1969 1977                                          };
1970 1978                                  };
1971 1979  $if _x86
1972 1980          _sys_fpelist            {
1973 1981                                    ASSERT = {
1974 1982                                            TYPE = OBJECT;
1975 1983                                            SIZE = addrsize[9];
1976 1984                                          };
1977 1985                                  };
1978 1986  $else
1979 1987          _sys_fpelist            {
1980 1988                                    ASSERT = {
1981 1989                                            TYPE = OBJECT;
1982 1990                                            SIZE = addrsize[8];
1983 1991                                          };
1984 1992                                  };
1985 1993  $endif
1986 1994          _sys_illlist            {
1987 1995                                    ASSERT = {
1988 1996                                            TYPE = OBJECT;
1989 1997                                            SIZE = addrsize[8];
1990 1998                                          };
1991 1999                                  };
1992 2000          _sys_segvlist           {
1993 2001                                    ASSERT = {
1994 2002                                            TYPE = OBJECT;
1995 2003                                            SIZE = addrsize[2];
1996 2004                                          };
1997 2005                                  };
1998 2006          _sys_siginfolistp       {
1999 2007                                    ASSERT = {
2000 2008                                            TYPE = OBJECT;
2001 2009                                            SIZE = addrsize;
2002 2010                                          };
2003 2011                                  };
2004 2012          _sys_siglist            {
2005 2013                                    ASSERT = {
2006 2014                                            TYPE = OBJECT;
2007 2015                                            SIZE = addrsize[34];
2008 2016                                          };
2009 2017                                  };
2010 2018          _sys_siglistn           {
2011 2019                                    ASSERT = {
2012 2020                                            TYPE = OBJECT;
2013 2021                                            SIZE = 4;
2014 2022                                          };
2015 2023                                  };
2016 2024          _sys_siglistp           {
2017 2025                                    ASSERT = {
2018 2026                                            TYPE = OBJECT;
2019 2027                                            SIZE = addrsize;
2020 2028                                          };
2021 2029                                  };
2022 2030          _sys_traplist           {
2023 2031                                    ASSERT = {
2024 2032                                            TYPE = OBJECT;
2025 2033                                            SIZE = addrsize[6];
2026 2034                                          };
2027 2035                                  };
2028 2036          valloc                  { FLAGS = NODIRECT; };
2029 2037  
2030 2038  $if _ELF32
2031 2039  $if _x86
2032 2040          _bufendtab              {
2033 2041                                    ASSERT = {
2034 2042                                            TYPE = OBJECT;
2035 2043                                            SIZE = 244;
2036 2044                                          };
2037 2045                                  };
2038 2046  $else
2039 2047          _bufendtab              {
2040 2048                                    ASSERT = {
2041 2049                                            TYPE = OBJECT;
2042 2050                                            SIZE = 84;
2043 2051                                          };
2044 2052                                  };
2045 2053  $endif
2046 2054          _lastbuf                {
2047 2055                                    ASSERT = {
2048 2056                                            TYPE = OBJECT;
2049 2057                                            SIZE = 4;
2050 2058                                          };
2051 2059                                  };
2052 2060          sys_errlist             {
2053 2061                                    ASSERT = {
2054 2062                                            TYPE = OBJECT;
2055 2063                                            SIZE = 608;
2056 2064                                          };
2057 2065                                  };
2058 2066          sys_nerr                {
2059 2067                                    ASSERT = {
2060 2068                                            BINDING = WEAK;
2061 2069                                            ALIAS = _sys_num_err;
2062 2070                                          };
2063 2071                                  };
2064 2072          _sys_nsig               {
2065 2073                                    ASSERT = {
2066 2074                                            TYPE = OBJECT;
2067 2075                                            SIZE = 4;
2068 2076                                          };
2069 2077                                  };
2070 2078  $endif
2071 2079  
2072 2080      protected:
2073 2081          a64l;
2074 2082          adjtime;
2075 2083          ascftime;
2076 2084          _assert;
2077 2085          atoll;
2078 2086          brk;
2079 2087          __builtin_alloca;
2080 2088          cftime;
2081 2089          closelog;
2082 2090          csetcol;
2083 2091          csetlen;
2084 2092          ctermid_r;
2085 2093          dbm_close;
2086 2094          dbm_delete;
2087 2095          dbm_fetch;
2088 2096          dbm_firstkey;
2089 2097          dbm_nextkey;
2090 2098          dbm_open;
2091 2099          dbm_store;
2092 2100          decimal_to_double;
2093 2101          decimal_to_extended;
2094 2102          decimal_to_quadruple;
2095 2103          decimal_to_single;
2096 2104          double_to_decimal;
2097 2105          drand48;
2098 2106          econvert;
2099 2107          ecvt;
2100 2108          endnetgrent;
2101 2109          endspent;
2102 2110          endutent;
2103 2111          endutxent;
2104 2112          erand48;
2105 2113          euccol;
2106 2114          euclen;
2107 2115          eucscol;
2108 2116          extended_to_decimal;
2109 2117          fchroot;
2110 2118          fconvert;
2111 2119          fcvt;
2112 2120          ffs;
2113 2121          fgetspent;
2114 2122          fgetspent_r;
2115 2123          _filbuf;
2116 2124          file_to_decimal;
2117 2125          finite;
2118 2126          _flsbuf;
2119 2127          fork1                   { FLAGS = NODYNSORT; };
2120 2128          fpclass;
2121 2129          fpgetmask;
2122 2130          fpgetsticky;
2123 2131          fpsetmask;
2124 2132          fpsetsticky;
2125 2133          fstatfs;
2126 2134          ftruncate;
2127 2135          ftw;
2128 2136          func_to_decimal;
2129 2137          gconvert;
2130 2138          gcvt;
2131 2139          getdents;
2132 2140          gethrtime;
2133 2141          gethrvtime;
2134 2142          getmntany;
2135 2143          getmntent;
2136 2144          getnetgrent;
2137 2145          getnetgrent_r;
2138 2146          getpw;
2139 2147          getspent;
2140 2148          getspent_r;
2141 2149          getspnam;
2142 2150          getspnam_r;
2143 2151          getutent;
2144 2152          getutid;
2145 2153          getutline;
2146 2154          getutmp;
2147 2155          getutmpx;
2148 2156          getutxent;
2149 2157          getutxid;
2150 2158          getutxline;
2151 2159          getvfsany;
2152 2160          getvfsent;
2153 2161          getvfsfile;
2154 2162          getvfsspec;
2155 2163          getwidth;
2156 2164          gsignal;
2157 2165          hasmntopt;
2158 2166          innetgr;
2159 2167          insque;
2160 2168          _insque;
2161 2169          jrand48;
2162 2170          l64a;
2163 2171          ladd;
2164 2172          lckpwdf;
2165 2173          lcong48;
2166 2174          ldivide;
2167 2175          lexp10;
2168 2176          llabs;
2169 2177          lldiv;
2170 2178          llog10;
2171 2179          llseek;
2172 2180          lltostr;
2173 2181          lmul;
2174 2182          lrand48;
2175 2183          lshiftl;
2176 2184          lsub;
2177 2185          _lwp_cond_broadcast;
2178 2186          _lwp_cond_signal;
2179 2187          _lwp_cond_timedwait;
2180 2188          _lwp_cond_wait;
2181 2189          _lwp_continue;
2182 2190          _lwp_info;
2183 2191          _lwp_kill;
2184 2192          _lwp_mutex_lock;
2185 2193          _lwp_mutex_trylock;
2186 2194          _lwp_mutex_unlock;
2187 2195          _lwp_self;
2188 2196          _lwp_sema_init;
2189 2197          _lwp_sema_post;
2190 2198          _lwp_sema_wait;
2191 2199          _lwp_suspend;
2192 2200          madvise;
2193 2201          __major;
2194 2202          __makedev;
2195 2203          mincore;
2196 2204          __minor;
2197 2205          mkstemp;
2198 2206          _mkstemp;
2199 2207          mlockall;
2200 2208          mrand48;
2201 2209          munlockall;
2202 2210          _mutex_held             { FLAGS = NODYNSORT; };
2203 2211          _mutex_lock             { FLAGS = NODYNSORT; };
2204 2212          nrand48;
2205 2213          _nss_netdb_aliases;
2206 2214          _nss_XbyY_buf_alloc;
2207 2215          _nss_XbyY_buf_free;
2208 2216          __nsw_extended_action;
2209 2217          __nsw_freeconfig;
2210 2218          __nsw_getconfig;
2211 2219          openlog;
2212 2220          plock;
2213 2221          p_online;
2214 2222          pread;
2215 2223          __priocntl;
2216 2224          __priocntlset;
2217 2225          processor_bind;
2218 2226          processor_info;
2219 2227          psiginfo;
2220 2228          psignal;
2221 2229          putpwent;
2222 2230          putspent;
2223 2231          pututline;
2224 2232          pututxline;
2225 2233          pwrite;
2226 2234          qeconvert;
2227 2235          qecvt;
2228 2236          qfconvert;
2229 2237          qfcvt;
2230 2238          qgconvert;
2231 2239          qgcvt;
2232 2240          quadruple_to_decimal;
2233 2241          realpath;
2234 2242          remque;
2235 2243          _remque;
2236 2244          _rw_read_held;
2237 2245          _rw_write_held;
2238 2246          seconvert;
2239 2247          seed48;
2240 2248          select;
2241 2249          _sema_held;
2242 2250          setegid;
2243 2251          seteuid;
2244 2252          setlogmask;
2245 2253          setnetgrent;
2246 2254          setspent;
2247 2255          settimeofday;
2248 2256          setutent;
2249 2257          setutxent;
2250 2258          sfconvert;
2251 2259          sgconvert;
2252 2260          sig2str;
2253 2261          sigwait;
2254 2262          single_to_decimal;
2255 2263          srand48;
2256 2264          ssignal;
2257 2265          statfs;
2258 2266          str2sig;
2259 2267          strcasecmp;
2260 2268          string_to_decimal;
2261 2269          strncasecmp;
2262 2270          strsignal;
2263 2271          strtoll;
2264 2272          strtoull;
2265 2273          swapctl;
2266 2274          _syscall;
2267 2275          sysfs;
2268 2276          syslog;
2269 2277          _syslog;
2270 2278          tmpnam_r;
2271 2279          truncate;
2272 2280          ttyslot;
2273 2281          uadmin;
2274 2282          ulckpwdf;
2275 2283          ulltostr;
2276 2284          unordered;
2277 2285          updwtmp;
2278 2286          updwtmpx;
2279 2287          ustat;
2280 2288          utimes;
2281 2289          utmpname;
2282 2290          utmpxname;
2283 2291          vfork;
2284 2292          vhangup;
2285 2293          vsyslog;
2286 2294          yield;
2287 2295  $if i386
2288 2296          # Note: _syscall is also defined above.  Here, we add the NODYNSORT
2289 2297          # attribute to it.  On this platform, _syscall is an alias to syscall
2290 2298          # If that is changed, this lines should be removed.
2291 2299          _syscall        { FLAGS = NODYNSORT; };
2292 2300  $endif
2293 2301  
2294 2302          # The 32-bit sparc ABI requires SISCD_2.3. On other platforms, those symbols
2295 2303          # go directly into SUNW_0.7.
2296 2304  $if sparc32
2297 2305  } SISCD_2.3;
2298 2306  
2299 2307  SYMBOL_VERSION SISCD_2.3 {
2300 2308  $endif
2301 2309  
2302 2310      global:
2303 2311          errno           {
2304 2312                            ASSERT = {
2305 2313                                    TYPE = OBJECT;
2306 2314                                    SIZE = 4;
2307 2315                                  };
2308 2316                            FLAGS = NODIRECT;
2309 2317                          };
2310 2318  
2311 2319  $if _ELF64
2312 2320          _iob            { ASSERT = { TYPE = OBJECT; SIZE = 2560; }; };
2313 2321  $elif _ELF32
2314 2322  $if _x86
2315 2323          _iob            { ASSERT = { TYPE = OBJECT; SIZE = 960; }; };
2316 2324  $else
2317 2325          _iob            { ASSERT = { TYPE = OBJECT; SIZE = 320; }; };
2318 2326  $endif
2319 2327  $else
2320 2328  $error unknown ELFCLASS
2321 2329  $endif
2322 2330  
2323 2331      protected:
2324 2332          addseverity;
2325 2333          _addseverity;
2326 2334          asctime_r;
2327 2335          crypt;
2328 2336          _crypt;
2329 2337          ctime_r;
2330 2338          encrypt;
2331 2339          _encrypt;
2332 2340          endgrent;
2333 2341          endpwent;
2334 2342          ___errno;
2335 2343          fgetgrent;
2336 2344          fgetgrent_r;
2337 2345          fgetpwent;
2338 2346          fgetpwent_r;
2339 2347          flockfile;
2340 2348          funlockfile;
2341 2349          getchar_unlocked;
2342 2350          getc_unlocked;
2343 2351          getgrent;
2344 2352          getgrent_r;
2345 2353          getgrgid_r;
2346 2354          getgrnam_r;
2347 2355          getitimer;
2348 2356          _getitimer;
2349 2357          getlogin_r;
2350 2358          getpwent;
2351 2359          getpwent_r;
2352 2360          getpwnam_r;
2353 2361          getpwuid_r;
2354 2362          gettimeofday;
2355 2363          _gettimeofday;
2356 2364          gmtime_r;
2357 2365          localtime_r;
2358 2366          putchar_unlocked;
2359 2367          putc_unlocked;
2360 2368          rand_r;
2361 2369          readdir_r;
2362 2370          setgrent;
2363 2371          setitimer;
2364 2372          _setitimer;
2365 2373          setkey;
2366 2374          _setkey;
2367 2375          setpwent;
2368 2376          strtok_r;
2369 2377          sysinfo;
2370 2378          _sysinfo;
2371 2379          ttyname_r;
2372 2380  
2373 2381  $if _ELF32
2374 2382          __div64;
2375 2383          __mul64;
2376 2384          __rem64;
2377 2385          __udiv64;
2378 2386          __urem64;
2379 2387  $endif
2380 2388  
2381 2389  $if sparc32
2382 2390          __dtoll;
2383 2391          __dtoull;
2384 2392          __ftoll;
2385 2393          __ftoull;
2386 2394          _Q_lltoq;
2387 2395          _Q_qtoll;
2388 2396          _Q_qtoull;
2389 2397          _Q_ulltoq;
2390 2398          sbrk;
2391 2399          _sbrk;
2392 2400          __umul64        { FLAGS = NODYNSORT; }; # Same address as __mul64
2393 2401  $endif
2394 2402  
2395 2403          # On 32-bit platforms, the following symbols go into SYSVABI_1.3, but
2396 2404          # on other platforms they go directly into the current version (which
2397 2405          # will be either SUNW_0.7, or SISCD_2.3, depending on the similar
2398 2406          # issue described above.
2399 2407  $if _ELF32
2400 2408  } SYSVABI_1.3;
2401 2409  
2402 2410  SYMBOL_VERSION SYSVABI_1.3 {
2403 2411  $endif
2404 2412  
2405 2413      global:
2406 2414          _altzone        { ASSERT = { BINDING = WEAK; ALIAS = altzone; }; };
2407 2415          calloc          { FLAGS = NODIRECT; };
2408 2416          __ctype         {
2409 2417                            ASSERT = {
2410 2418                                    TYPE = OBJECT;
2411 2419                                    SIZE = 521;
2412 2420                                  };
2413 2421                          };
2414 2422          daylight        { ASSERT = { TYPE = OBJECT; SIZE = 4; }; };
2415 2423          _daylight       { ASSERT = { BINDING = WEAK; ALIAS = daylight; }; };
2416 2424          environ         {
2417 2425                            ASSERT = {
2418 2426                                    BINDING = WEAK;
2419 2427                                    ALIAS = _environ;
2420 2428                                  };
2421 2429                            FLAGS = NODIRECT;
2422 2430                          };
2423 2431          _environ        {
2424 2432                            ASSERT = {
2425 2433                                    TYPE = OBJECT;
2426 2434                                    SIZE = addrsize;
2427 2435                                  };
2428 2436                            FLAGS = NODIRECT;
2429 2437                          };
2430 2438          free            { FLAGS = NODIRECT; };
2431 2439          frexp           { TYPE = FUNCTION; FILTER = libm.so.2; };
2432 2440          getdate_err     { ASSERT = { TYPE = OBJECT; SIZE = 4; }; };
2433 2441          _getdate_err    {
2434 2442                            ASSERT = {
2435 2443                                    BINDING = WEAK;
2436 2444                                    ALIAS = getdate_err;
2437 2445                                  };
2438 2446                          };
2439 2447          getenv;
2440 2448          __huge_val      { ASSERT = { TYPE = OBJECT; SIZE = 8; }; };
2441 2449          __iob           { ASSERT = { BINDING = WEAK; ALIAS = _iob; }; };
2442 2450          isnan           { TYPE = FUNCTION; FILTER = libm.so.2; };
2443 2451          _isnan          { TYPE = FUNCTION; FILTER = libm.so.2; };
2444 2452          isnand          { TYPE = FUNCTION; FILTER = libm.so.2; };
2445 2453          _isnand         { TYPE = FUNCTION; FILTER = libm.so.2; };
2446 2454          ldexp           { TYPE = FUNCTION; FILTER = libm.so.2; };
2447 2455          logb            { TYPE = FUNCTION; FILTER = libm.so.2; };
2448 2456          malloc          { FLAGS = NODIRECT; };
2449 2457          memcmp;
2450 2458          memcpy;
2451 2459          memmove;
2452 2460          memset;
2453 2461          modf            { TYPE = FUNCTION; FILTER = libm.so.2; };
2454 2462          _modf           { TYPE = FUNCTION; FILTER = libm.so.2; };
2455 2463          nextafter       { TYPE = FUNCTION; FILTER = libm.so.2; };
2456 2464          _nextafter      { TYPE = FUNCTION; FILTER = libm.so.2; };
2457 2465          _numeric        { ASSERT = { TYPE = OBJECT; SIZE = 2; }; };
2458 2466          optarg          {
2459 2467                            ASSERT = {
2460 2468                                    TYPE = OBJECT;
2461 2469                                    SIZE = addrsize;
2462 2470                                  };
2463 2471                          };
2464 2472          opterr          { ASSERT = { TYPE = OBJECT; SIZE = 4; }; };
2465 2473          optind          { ASSERT = { TYPE = OBJECT; SIZE = 4; }; };
2466 2474          optopt          { ASSERT = { TYPE = OBJECT; SIZE = 4; }; };
2467 2475          realloc         { FLAGS = NODIRECT; };
2468 2476          scalb           { TYPE = FUNCTION; FILTER = libm.so.2; };
2469 2477          _scalb          { TYPE = FUNCTION; FILTER = libm.so.2; };
2470 2478          timezone        {
2471 2479                            ASSERT = {
2472 2480                                    TYPE = OBJECT;
2473 2481                                    SIZE = addrsize;
2474 2482                                  };
2475 2483                          };
2476 2484          _timezone       { ASSERT = { BINDING = WEAK; ALIAS = timezone; }; };
2477 2485          tzname          {
2478 2486                            ASSERT = {
2479 2487                                    TYPE = OBJECT;
2480 2488                                    SIZE = addrsize[2];
2481 2489                                  };
2482 2490                          };
2483 2491          _tzname         {
2484 2492                            ASSERT = {
2485 2493                                    BINDING = WEAK;
2486 2494                                    ALIAS = tzname;
2487 2495                                  };
2488 2496                          };
2489 2497  $if i386
2490 2498          _fp_hw          { ASSERT = { TYPE = OBJECT; SIZE = 4; }; };
2491 2499  $endif
2492 2500  
2493 2501      protected:
2494 2502          abort;
2495 2503          abs;
2496 2504          access;
2497 2505          _access;
2498 2506          acct;
2499 2507          _acct;
2500 2508          alarm;
2501 2509          _alarm;
2502 2510          asctime;
2503 2511          __assert;
2504 2512          atexit;
2505 2513          atof;
2506 2514          atoi;
2507 2515          atol;
2508 2516          bsearch;
2509 2517          catclose;
2510 2518          _catclose;
2511 2519          catgets;
2512 2520          _catgets;
2513 2521          catopen;
2514 2522          _catopen;
2515 2523          cfgetispeed;
2516 2524          _cfgetispeed;
2517 2525          cfgetospeed;
2518 2526          _cfgetospeed;
2519 2527          cfsetispeed;
2520 2528          _cfsetispeed;
2521 2529          cfsetospeed;
2522 2530          _cfsetospeed;
2523 2531          chdir;
2524 2532          _chdir;
2525 2533          chmod;
2526 2534          _chmod;
2527 2535          chown;
2528 2536          _chown;
2529 2537          chroot;
2530 2538          _chroot;
2531 2539          _cleanup;
2532 2540          clearerr;
2533 2541          clock;
2534 2542          close;
2535 2543          _close;
2536 2544          closedir;
2537 2545          _closedir;
2538 2546          creat;
2539 2547          _creat;
2540 2548          ctermid;
2541 2549          ctime;
2542 2550          cuserid;
2543 2551          _cuserid;
2544 2552          difftime;
2545 2553          div;
2546 2554          dup;
2547 2555          _dup;
2548 2556          dup2;
2549 2557          _dup2;
2550 2558          execl;
2551 2559          _execl;
2552 2560          execle;
2553 2561          _execle;
2554 2562          execlp;
2555 2563          _execlp;
2556 2564          execv;
2557 2565          _execv;
2558 2566          execve;
2559 2567          _execve;
2560 2568          execvp;
2561 2569          _execvp;
2562 2570          exit;
2563 2571          _exit;
2564 2572          fattach;
2565 2573          _fattach;
2566 2574          fchdir;
2567 2575          _fchdir;
2568 2576          fchmod;
2569 2577          _fchmod;
2570 2578          fchown;
2571 2579          _fchown;
2572 2580          fclose;
2573 2581          fcntl;
2574 2582          _fcntl;
2575 2583          fdetach;
2576 2584          _fdetach;
2577 2585          fdopen;
2578 2586          _fdopen;
2579 2587          feof;
2580 2588          ferror;
2581 2589          fflush;
2582 2590          fgetc;
2583 2591          fgetpos;
2584 2592          fgets;
2585 2593          __filbuf;
2586 2594          fileno;
2587 2595          _fileno;
2588 2596          __flsbuf;
2589 2597          fmtmsg;
2590 2598          _fmtmsg;
2591 2599          fopen;
2592 2600          _fork;
2593 2601          fork;
2594 2602          fpathconf;
2595 2603          _fpathconf;
2596 2604          fprintf;
2597 2605          fputc;
2598 2606          fputs;
2599 2607          fread;
2600 2608          freopen;
2601 2609          fscanf;
2602 2610          fseek;
2603 2611          fsetpos;
2604 2612          fstat;
2605 2613          _fstat;
2606 2614          fstatvfs;
2607 2615          _fstatvfs;
2608 2616          fsync;
2609 2617          _fsync;
2610 2618          ftell;
2611 2619          ftok;
2612 2620          _ftok;
2613 2621          fwrite;
2614 2622          getc;
2615 2623          getchar;
2616 2624          getcontext;
2617 2625          _getcontext;
2618 2626          getcwd;
2619 2627          _getcwd;
2620 2628          getdate;
2621 2629          _getdate;
2622 2630          getegid;
2623 2631          _getegid;
2624 2632          geteuid;
2625 2633          _geteuid;
2626 2634          getgid;
2627 2635          _getgid;
2628 2636          getgrgid;
2629 2637          getgrnam;
2630 2638          getgroups;
2631 2639          _getgroups;
2632 2640          getlogin;
2633 2641          getmsg;
2634 2642          _getmsg;
2635 2643          getopt;
2636 2644          _getopt;
2637 2645          getpass;
2638 2646          _getpass;
2639 2647          getpgid;
2640 2648          _getpgid;
2641 2649          getpgrp;
2642 2650          _getpgrp;
2643 2651          getpid;
2644 2652          _getpid;
2645 2653          getpmsg;
2646 2654          _getpmsg;
2647 2655          getppid;
2648 2656          _getppid;
2649 2657          getpwnam;
2650 2658          getpwuid;
2651 2659          getrlimit;
2652 2660          _getrlimit;
2653 2661          gets;
2654 2662          getsid;
2655 2663          _getsid;
2656 2664          getsubopt;
2657 2665          _getsubopt;
2658 2666          gettxt;
2659 2667          _gettxt;
2660 2668          getuid;
2661 2669          _getuid;
2662 2670          getw;
2663 2671          _getw;
2664 2672          gmtime;
2665 2673          grantpt;
2666 2674          _grantpt;
2667 2675          hcreate;
2668 2676          _hcreate;
2669 2677          hdestroy;
2670 2678          _hdestroy;
2671 2679          hsearch;
2672 2680          _hsearch;
2673 2681          initgroups;
2674 2682          _initgroups;
2675 2683          ioctl;
2676 2684          _ioctl;
2677 2685          isalnum;
2678 2686          isalpha;
2679 2687          isascii;
2680 2688          _isascii;
2681 2689          isastream;
2682 2690          _isastream;
2683 2691          isatty;
2684 2692          _isatty;
2685 2693          iscntrl;
2686 2694          isdigit;
2687 2695          isgraph;
2688 2696          islower;
2689 2697          isprint;
2690 2698          ispunct;
2691 2699          isspace;
2692 2700          isupper;
2693 2701          isxdigit;
2694 2702          kill;
2695 2703          _kill;
2696 2704          labs;
2697 2705          lchown;
2698 2706          _lchown;
2699 2707          ldiv;
2700 2708          lfind;
2701 2709          _lfind;
2702 2710          link;
2703 2711          _link;
2704 2712          localeconv;
2705 2713          localtime;
2706 2714          lockf;
2707 2715          _lockf;
2708 2716          longjmp;
2709 2717          lsearch;
2710 2718          _lsearch;
2711 2719          lseek;
2712 2720          _lseek;
2713 2721          lstat;
2714 2722          _lstat;
2715 2723          makecontext;
2716 2724          _makecontext;
2717 2725          mblen;
2718 2726          mbstowcs;
2719 2727          mbtowc;
2720 2728          memccpy;
2721 2729          _memccpy;
2722 2730          memchr;
2723 2731          memcntl;
2724 2732          _memcntl;
2725 2733          mkdir;
2726 2734          _mkdir;
2727 2735          mkfifo;
2728 2736          _mkfifo;
2729 2737          mknod;
2730 2738          _mknod;
2731 2739          mktemp;
2732 2740          _mktemp;
2733 2741          mktime;
2734 2742          mlock;
2735 2743          _mlock;
2736 2744          mmap;
2737 2745          _mmap;
2738 2746          monitor;
2739 2747          _monitor;
2740 2748          mount;
2741 2749          _mount;
2742 2750          mprotect;
2743 2751          _mprotect;
2744 2752          msgctl;
2745 2753          _msgctl;
2746 2754          msgget;
2747 2755          _msgget;
2748 2756          msgrcv;
2749 2757          _msgrcv;
2750 2758          msgsnd;
2751 2759          _msgsnd;
2752 2760          msync;
2753 2761          _msync;
2754 2762          munlock;
2755 2763          _munlock;
2756 2764          munmap;
2757 2765          _munmap;
2758 2766          nftw;
2759 2767          _nftw;
2760 2768          nice;
2761 2769          _nice;
2762 2770          nl_langinfo;
2763 2771          _nl_langinfo;
2764 2772          open;
2765 2773          _open;
2766 2774          opendir;
2767 2775          _opendir;
2768 2776          pathconf;
2769 2777          _pathconf;
2770 2778          pause;
2771 2779          _pause;
2772 2780          pclose;
2773 2781          _pclose;
2774 2782          perror;
2775 2783          pipe;
2776 2784          _pipe;
2777 2785          poll;
2778 2786          _poll;
2779 2787          popen;
2780 2788          _popen;
2781 2789          printf;
2782 2790          profil;
2783 2791          _profil;
2784 2792          ptsname;
2785 2793          _ptsname;
2786 2794          putc;
2787 2795          putchar;
2788 2796          putenv;
2789 2797          _putenv;
2790 2798          putmsg;
2791 2799          _putmsg;
2792 2800          putpmsg;
2793 2801          _putpmsg;
2794 2802          puts;
2795 2803          putw;
2796 2804          _putw;
2797 2805          qsort;
2798 2806          raise;
2799 2807          rand;
2800 2808          read;
2801 2809          _read;
2802 2810          readdir;
2803 2811          _readdir;
2804 2812          readlink;
2805 2813          _readlink;
2806 2814          readv;
2807 2815          _readv;
2808 2816          remove;
2809 2817          rename;
2810 2818          _rename;
2811 2819          rewind;
2812 2820          rewinddir;
2813 2821          _rewinddir;
2814 2822          rmdir;
2815 2823          _rmdir;
2816 2824          scanf;
2817 2825          seekdir;
2818 2826          _seekdir;
2819 2827          semctl;
2820 2828          _semctl;
2821 2829          semget;
2822 2830          _semget;
2823 2831          semop;
2824 2832          _semop;
2825 2833          setbuf;
2826 2834          setcontext;
2827 2835          _setcontext     { FLAGS = NODYNSORT; };
2828 2836          setgid;
2829 2837          _setgid;
2830 2838          setgroups;
2831 2839          _setgroups;
2832 2840          setjmp;
2833 2841          setlabel;
2834 2842          setlocale;
2835 2843          setpgid;
2836 2844          _setpgid;
2837 2845          setpgrp;
2838 2846          _setpgrp;
2839 2847          setrlimit;
2840 2848          _setrlimit;
2841 2849          setsid;
2842 2850          _setsid;
2843 2851          setuid;
2844 2852          _setuid;
2845 2853          setvbuf;
2846 2854          shmat;
2847 2855          _shmat;
2848 2856          shmctl;
2849 2857          _shmctl;
2850 2858          shmdt;
2851 2859          _shmdt;
2852 2860          shmget;
2853 2861          _shmget;
2854 2862          sigaction;
2855 2863          _sigaction      { FLAGS = NODYNSORT; };
2856 2864          sigaddset;
2857 2865          _sigaddset;
2858 2866          sigaltstack;
2859 2867          _sigaltstack;
2860 2868          sigdelset;
2861 2869          _sigdelset;
2862 2870          sigemptyset;
2863 2871          _sigemptyset;
2864 2872          sigfillset;
2865 2873          _sigfillset;
2866 2874          sighold;
2867 2875          _sighold;
2868 2876          sigignore;
2869 2877          _sigignore;
2870 2878          sigismember;
2871 2879          _sigismember;
2872 2880          siglongjmp;
2873 2881          _siglongjmp;
2874 2882          signal;
2875 2883          sigpause;
2876 2884          _sigpause;
2877 2885          sigpending;
2878 2886          _sigpending;
2879 2887          sigprocmask;
2880 2888          _sigprocmask;
2881 2889          sigrelse;
2882 2890          _sigrelse;
2883 2891          sigsend;
2884 2892          _sigsend;
2885 2893          sigsendset;
2886 2894          _sigsendset;
2887 2895          sigset;
2888 2896          _sigset;
2889 2897          sigsetjmp;
2890 2898          _sigsetjmp      { FLAGS = NODYNSORT; };
2891 2899          sigsuspend;
2892 2900          _sigsuspend;
2893 2901          sleep;
2894 2902          _sleep;
2895 2903          sprintf;
2896 2904          srand;
2897 2905          sscanf;
2898 2906          stat;
2899 2907          _stat;
2900 2908          statvfs;
2901 2909          _statvfs;
2902 2910          stime;
2903 2911          _stime;
2904 2912          strcat;
2905 2913          strchr;
2906 2914          strcmp;
2907 2915          strcoll;
2908 2916          strcpy;
2909 2917          strcspn;
2910 2918          strdup;
2911 2919          _strdup;
2912 2920          strerror;
2913 2921          strftime;
2914 2922          strlen;
2915 2923          strncat;
2916 2924          strncmp;
2917 2925          strncpy;
2918 2926          strpbrk;
2919 2927          strrchr;
2920 2928          strspn;
2921 2929          strstr;
2922 2930          strtod;
2923 2931          strtok;
2924 2932          strtol;
2925 2933          strtoul;
2926 2934          strxfrm;
2927 2935          swab;
2928 2936          _swab;
2929 2937          swapcontext;
2930 2938          _swapcontext;
2931 2939          symlink;
2932 2940          _symlink;
2933 2941          sync;
2934 2942          _sync;
2935 2943          sysconf;
2936 2944          _sysconf;
2937 2945          system;
2938 2946          tcdrain;
2939 2947          _tcdrain;
2940 2948          tcflow;
2941 2949          _tcflow;
2942 2950          tcflush;
2943 2951          _tcflush;
2944 2952          tcgetattr;
2945 2953          _tcgetattr;
2946 2954          tcgetpgrp;
2947 2955          _tcgetpgrp;
2948 2956          tcgetsid;
2949 2957          _tcgetsid;
2950 2958          tcsendbreak;
2951 2959          _tcsendbreak;
2952 2960          tcsetattr;
2953 2961          _tcsetattr;
2954 2962          tcsetpgrp;
2955 2963          _tcsetpgrp;
2956 2964          tdelete;
2957 2965          _tdelete;
2958 2966          tell;
2959 2967          _tell;
2960 2968          telldir;
2961 2969          _telldir;
2962 2970          tempnam;
2963 2971          _tempnam;
2964 2972          tfind;
2965 2973          _tfind;
2966 2974          time;
2967 2975          _time;
2968 2976          times;
2969 2977          _times;
2970 2978          tmpfile;
2971 2979          tmpnam;
2972 2980          toascii;
2973 2981          _toascii;
2974 2982          tolower;
2975 2983          _tolower;
2976 2984          toupper;
2977 2985          _toupper;
2978 2986          tsearch;
2979 2987          _tsearch;
2980 2988          ttyname;
2981 2989          twalk;
2982 2990          _twalk;
2983 2991          tzset;
2984 2992          _tzset;
2985 2993          ulimit;
2986 2994          _ulimit;
2987 2995          umask;
2988 2996          _umask;
2989 2997          umount;
2990 2998          _umount;
2991 2999          uname;
2992 3000          _uname;
2993 3001          ungetc;
2994 3002          unlink;
2995 3003          _unlink;
2996 3004          unlockpt;
2997 3005          _unlockpt;
2998 3006          utime;
2999 3007          _utime;
3000 3008          vfprintf;
3001 3009          vprintf;
3002 3010          vsprintf;
3003 3011          wait;
3004 3012          _wait;
3005 3013          waitid;
3006 3014          _waitid;
3007 3015          waitpid;
3008 3016          _waitpid;
3009 3017          wcstombs;
3010 3018          wctomb;
3011 3019          write;
3012 3020          _write;
3013 3021          writev;
3014 3022          _writev;
3015 3023          _xftw;
3016 3024  
3017 3025  $if _ELF32
3018 3026          ptrace;
3019 3027          _ptrace;
3020 3028  $endif
3021 3029  
3022 3030  $if i386
3023 3031          _fxstat;
3024 3032          _lxstat;
3025 3033          nuname;
3026 3034          _nuname;
3027 3035          _xmknod;
3028 3036          _xstat;
3029 3037  $endif
3030 3038  
3031 3039  $if !sparc32
3032 3040          sbrk;
3033 3041  $endif
3034 3042  
3035 3043  $if _sparc
3036 3044          __dtou;
3037 3045          __ftou;
3038 3046  $endif
3039 3047  
3040 3048  $if sparc32
3041 3049          .div;
3042 3050          .mul;
3043 3051          .rem;
3044 3052          .stret1;
3045 3053          .stret2;
3046 3054          .stret4;
3047 3055          # .stret4 and .stret8 are the same thing
3048 3056          .stret8         { FLAGS = NODYNSORT; };
3049 3057          .udiv;
3050 3058          .umul;
3051 3059          .urem;
3052 3060          _Q_add;
3053 3061          _Q_cmp;
3054 3062          _Q_cmpe;
3055 3063          _Q_div;
3056 3064          _Q_dtoq;
3057 3065          _Q_feq;
3058 3066          _Q_fge;
3059 3067          _Q_fgt;
3060 3068          _Q_fle;
3061 3069          _Q_flt;
3062 3070          _Q_fne;
3063 3071          _Q_itoq;
3064 3072          _Q_mul;
3065 3073          _Q_neg;
3066 3074          _Q_qtod;
3067 3075          _Q_qtoi;
3068 3076          _Q_qtos;
3069 3077          _Q_qtou;
3070 3078          _Q_sqrt;
3071 3079          _Q_stoq;
3072 3080          _Q_sub;
3073 3081          _Q_utoq;
3074 3082  $endif
3075 3083  
3076 3084  $if sparcv9
3077 3085          # __align_cpy_1 is an alias for memcpy. Filter it out of
3078 3086          # the .SUNW_dynsymsort section
3079 3087          __align_cpy_1   { FLAGS = NODYNSORT; };
3080 3088          __align_cpy_16;
3081 3089          __align_cpy_2;
3082 3090          __align_cpy_4;
3083 3091          # __align_cpy_8 is same as __align_cpy_16
3084 3092          __align_cpy_8   { FLAGS = NODYNSORT; };
3085 3093          __dtoul;
3086 3094          __ftoul;
3087 3095          _Qp_add;
3088 3096          _Qp_cmp;
3089 3097          _Qp_cmpe;
3090 3098          _Qp_div;
3091 3099          _Qp_dtoq;
3092 3100          _Qp_feq;
3093 3101          _Qp_fge;
3094 3102          _Qp_fgt;
3095 3103          _Qp_fle;
3096 3104          _Qp_flt;
3097 3105          _Qp_fne;
3098 3106          _Qp_itoq;
3099 3107          _Qp_mul;
3100 3108          _Qp_neg;
3101 3109          _Qp_qtod;
3102 3110          _Qp_qtoi;
3103 3111          _Qp_qtos;
3104 3112          _Qp_qtoui;
3105 3113          _Qp_qtoux;
3106 3114          _Qp_qtox;
3107 3115          _Qp_sqrt;
3108 3116          _Qp_stoq;
3109 3117          _Qp_sub;
3110 3118          _Qp_uitoq;
3111 3119          _Qp_uxtoq;
3112 3120          _Qp_xtoq;
3113 3121          __sparc_utrap_install;
3114 3122  $endif
3115 3123  
3116 3124          # On amd64, we also have SYSVABI_1.3, but it contains a small subset of
3117 3125          # the symbols put in that version on other platforms.
3118 3126  $if amd64
3119 3127  } SYSVABI_1.3;
3120 3128  
3121 3129  SYMBOL_VERSION SYSVABI_1.3 {
3122 3130  $endif
3123 3131      global:
3124 3132  $if !_sparc
3125 3133          __flt_rounds    { ASSERT = { TYPE = OBJECT; SIZE = 4; }; };
3126 3134  $endif
3127 3135  
3128 3136      protected:
3129 3137          _ctermid;
3130 3138          _getgrgid;
3131 3139          _getgrnam;
3132 3140          _getlogin;
3133 3141          _getpwnam;
3134 3142          _getpwuid;
3135 3143          _ttyname;
3136 3144  
3137 3145  $if !sparc32
3138 3146          _sbrk;
3139 3147  $endif
3140 3148  
3141 3149  $if _x86
3142 3150          _fpstart;
3143 3151          __fpstart;
3144 3152  $endif
3145 3153  };
3146 3154  
3147 3155  
3148 3156  
3149 3157  # There should never be more than one SUNWprivate version.
3150 3158  # Don't add any more.  Add new private symbols to SUNWprivate_1.1
3151 3159  
3152 3160  SYMBOL_VERSION SUNWprivate_1.1 {
3153 3161      global:
3154 3162          ___Argv                 {
3155 3163                                    FLAGS = NODIRECT;
3156 3164                                    ASSERT = {
3157 3165                                            TYPE = OBJECT;
3158 3166                                            SIZE = addrsize;
3159 3167                                          };
3160 3168                                  };
3161 3169          cfree                   { FLAGS = NODIRECT; };
3162 3170          _cswidth                {
3163 3171                                    ASSERT = {
3164 3172                                            TYPE = OBJECT;
3165 3173                                            SIZE = 16;
3166 3174                                          };
3167 3175                                  };
3168 3176          __ctype_mask            {
3169 3177                                    ASSERT = {
3170 3178                                            TYPE = OBJECT;
3171 3179                                            SIZE = addrsize;
3172 3180                                          };
3173 3181                                  };
3174 3182          __environ_lock          {
3175 3183                                    FLAGS = NODIRECT;
3176 3184                                    ASSERT = {
3177 3185                                            TYPE = OBJECT;
3178 3186                                            SIZE = 24;
3179 3187                                          };
3180 3188                                  };
3181 3189          __inf_read              {
3182 3190                                    ASSERT = {
3183 3191                                            TYPE = OBJECT;
3184 3192                                            SIZE = 4;
3185 3193                                          };
3186 3194                                  };
3187 3195          __inf_written           {
3188 3196                                    ASSERT = {
3189 3197                                            TYPE = OBJECT;
3190 3198                                            SIZE = 4;
3191 3199                                          };
3192 3200                                  };
3193 3201          __i_size                {
3194 3202                                    ASSERT = {
3195 3203                                            TYPE = OBJECT;
3196 3204                                            SIZE = 4;
3197 3205                                          };
3198 3206                                  };
3199 3207          _isnanf                 {
3200 3208                                    TYPE = FUNCTION;
3201 3209                                    FILTER = libm.so.2;
3202 3210                                  };
3203 3211          __iswrune;
3204 3212          __libc_threaded         {
3205 3213                                    ASSERT = {
3206 3214                                            TYPE = OBJECT;
3207 3215                                            SIZE = 4;
3208 3216                                          };
3209 3217                                  };
3210 3218          _lib_version            {
3211 3219                                    ASSERT = {
3212 3220                                            TYPE = OBJECT;
3213 3221                                            SIZE = 4;
3214 3222                                          };
3215 3223                                    FLAGS = NODIRECT;
3216 3224                                  };
3217 3225          _logb                   {
3218 3226                                    TYPE = FUNCTION;
3219 3227                                    FILTER = libm.so.2;
3220 3228                                  };
3221 3229          _lone                   {
3222 3230                                    FLAGS = NODYNSORT;
3223 3231                                    ASSERT = {
3224 3232                                            BINDING = WEAK;
3225 3233                                            ALIAS = lone;
3226 3234                                          };
3227 3235                                  };
3228 3236          _lten                   {
3229 3237                                    FLAGS = NODYNSORT;
3230 3238                                    ASSERT = {
3231 3239                                            BINDING = WEAK;
3232 3240                                            ALIAS = lten;
3233 3241                                          };
3234 3242                                  };
3235 3243          _lzero                  {
3236 3244                                    FLAGS = NODYNSORT;
3237 3245                                    ASSERT = {
3238 3246                                            BINDING = WEAK;
3239 3247                                            ALIAS = lzero;
3240 3248                                          };
3241 3249                                  };
3242 3250          __malloc_lock           {
3243 3251                                    ASSERT = {
3244 3252                                            TYPE = OBJECT;
3245 3253                                            SIZE = 24;
3246 3254                                          };
3247 3255                                  };
3248 3256          _memcmp;
3249 3257          _memcpy                 { FLAGS = NODYNSORT; };
3250 3258          _memmove;
3251 3259          _memset;
3252 3260          _modff                  {
3253 3261                                    TYPE = FUNCTION;
3254 3262                                    FILTER = libm.so.2;
3255 3263                                  };
3256 3264          __nan_read              {
3257 3265                                    ASSERT = {
3258 3266                                            TYPE = OBJECT;
3259 3267                                            SIZE = 4;
3260 3268                                          };
3261 3269                                  };
3262 3270          __nan_written           {
3263 3271                                    ASSERT = {
3264 3272                                            TYPE = OBJECT;
3265 3273                                            SIZE = 4;
3266 3274                                          };
3267 3275                                  };
3268 3276          __nextwctype;
3269 3277          __nis_debug_bind        {
3270 3278                                    ASSERT = {
3271 3279                                            TYPE = OBJECT;
3272 3280                                            SIZE = 4;
3273 3281                                          };
3274 3282                                  };
3275 3283          __nis_debug_calls       {
3276 3284                                    ASSERT = {
3277 3285                                            TYPE = OBJECT;
3278 3286                                            SIZE = 4;
3279 3287                                          };
3280 3288                                  };
3281 3289          __nis_debug_file        {
3282 3290                                    ASSERT = {
3283 3291                                            TYPE = OBJECT;
3284 3292                                            SIZE = addrsize;
3285 3293                                          };
3286 3294                                  };
3287 3295          __nis_debug_rpc         {
3288 3296                                    ASSERT = {
3289 3297                                            TYPE = OBJECT;
3290 3298                                            SIZE = 4;
3291 3299                                          };
3292 3300                                  };
3293 3301          __nis_prefsrv           {
3294 3302                                    ASSERT = {
3295 3303                                            TYPE = OBJECT;
3296 3304                                            SIZE = addrsize;
3297 3305                                          };
3298 3306                                  };
3299 3307          __nis_preftype          {
3300 3308                                    ASSERT = {
3301 3309                                            TYPE = OBJECT;
3302 3310                                            SIZE = addrsize;
3303 3311                                          };
3304 3312                                  };
3305 3313          __nis_server            {
3306 3314                                    ASSERT = {
3307 3315                                            TYPE = OBJECT;
3308 3316                                            SIZE = addrsize;
3309 3317                                          };
3310 3318                                  };
3311 3319          _nss_default_finders    {
3312 3320                                    ASSERT = {
3313 3321                                            BINDING = WEAK;
3314 3322                                            ALIAS = nss_default_finders;
3315 3323                                          };
3316 3324                                  };
3317 3325          __progname              {
3318 3326                                    ASSERT = {
3319 3327                                            TYPE = OBJECT;
3320 3328                                            SIZE = addrsize;
3321 3329                                          };
3322 3330                                    FLAGS = NODIRECT;
3323 3331                                  };
3324 3332  
3325 3333  $if _ELF64
3326 3334          _smbuf                  {
3327 3335                                    ASSERT = {
3328 3336                                            TYPE = OBJECT;
3329 3337                                            SIZE = 168;
3330 3338                                          };
3331 3339                                  };
3332 3340  $elif _ELF32
3333 3341  $if _x86
3334 3342          _smbuf                  {
3335 3343                                    ASSERT = {
3336 3344                                            TYPE = OBJECT;
3337 3345                                            SIZE = 488;
3338 3346                                          };
3339 3347                                  };
3340 3348  $else
3341 3349          _smbuf                  {
3342 3350                                    ASSERT = {
3343 3351                                            TYPE = OBJECT;
3344 3352                                            SIZE = 168;
3345 3353                                          };
3346 3354                                  };
3347 3355  $endif
3348 3356  $else
3349 3357  $error unknown ELFCLASS
3350 3358  $endif
3351 3359          _sp                     {
3352 3360                                    ASSERT = {
3353 3361                                            TYPE = OBJECT;
3354 3362                                            SIZE = 4;
3355 3363                                          };
3356 3364                                  };
3357 3365          __strdupa_str           {
3358 3366                                    ASSERT = {
3359 3367                                            TYPE = TLS;
3360 3368                                            SIZE = addrsize;
3361 3369                                          };
3362 3370                                    FLAGS = NODIRECT;
3363 3371                                  };
3364 3372          __strdupa_len           {
3365 3373                                    ASSERT = {
3366 3374                                            TYPE = TLS;
3367 3375                                            SIZE = addrsize;
3368 3376                                          };
3369 3377                                    FLAGS = NODIRECT;
3370 3378                                  };
3371 3379          _tdb_bootstrap          {
3372 3380                                    ASSERT = {
3373 3381                                            BINDING = WEAK;
3374 3382                                            ALIAS = __tdb_bootstrap;
3375 3383                                          };
3376 3384                                  };
3377 3385          __threaded              {
3378 3386                                    ASSERT = {
3379 3387                                            TYPE = OBJECT;
3380 3388                                            SIZE = 4;
3381 3389                                          };
3382 3390                                  };
3383 3391          thr_probe_getfunc_addr  {
3384 3392                                    ASSERT = {
3385 3393                                            TYPE = OBJECT;
3386 3394                                            SIZE = addrsize;
3387 3395                                          };
3388 3396                                  };
3389 3397          __trans_lower           {
3390 3398                                    ASSERT = {
3391 3399                                            TYPE = OBJECT;
3392 3400                                            SIZE = addrsize;
3393 3401                                          };
3394 3402                                  };
3395 3403          __trans_upper           {
3396 3404                                    ASSERT = {
3397 3405                                            TYPE = OBJECT;
3398 3406                                            SIZE = addrsize;
3399 3407                                          };
3400 3408                                  };
3401 3409          _uberdata               {
3402 3410                                    ASSERT = {
3403 3411                                            BINDING = WEAK;
3404 3412                                            ALIAS = __uberdata;
3405 3413                                          };
3406 3414                                  };
3407 3415          __xpg6                  {
3408 3416                                    ASSERT = {
3409 3417                                            TYPE = OBJECT;
3410 3418                                            SIZE = 4;
3411 3419                                          };
3412 3420                                    FLAGS = NODIRECT;
3413 3421                                  };
3414 3422  
3415 3423  $if _ELF32
3416 3424          _dladdr                 {
3417 3425                                    TYPE = FUNCTION;
3418 3426                                    FILTER = /usr/lib/ld.so.1;
3419 3427                                  };
3420 3428          _dladdr1                {
3421 3429                                    TYPE = FUNCTION;
3422 3430                                    FILTER = /usr/lib/ld.so.1;
3423 3431                                  };
3424 3432          _dlclose                {
3425 3433                                    TYPE = FUNCTION;
3426 3434                                    FILTER = /usr/lib/ld.so.1;
3427 3435                                  };
3428 3436          _dldump                 {
3429 3437                                    TYPE = FUNCTION;
3430 3438                                    FILTER = /usr/lib/ld.so.1;
3431 3439                                  };
3432 3440          _dlerror                {
3433 3441                                    TYPE = FUNCTION;
3434 3442                                    FILTER = /usr/lib/ld.so.1;
3435 3443                                  };
3436 3444          _dlinfo                 {
3437 3445                                    TYPE = FUNCTION;
3438 3446                                    FILTER = /usr/lib/ld.so.1;
3439 3447                                  };
3440 3448          _dlmopen                {
3441 3449                                    TYPE = FUNCTION;
3442 3450                                    FILTER = /usr/lib/ld.so.1;
3443 3451                                  };
3444 3452          _dlopen                 {
3445 3453                                    TYPE = FUNCTION;
3446 3454                                    FILTER = /usr/lib/ld.so.1;
3447 3455                                  };
3448 3456          _dlsym                  {
3449 3457                                    TYPE = FUNCTION;
3450 3458                                    FILTER = /usr/lib/ld.so.1;
3451 3459                                  };
3452 3460          _ld_libc                {
3453 3461                                    TYPE = FUNCTION;
3454 3462                                    FILTER = /usr/lib/ld.so.1;
3455 3463                                  };
3456 3464          _sys_errlist            {
3457 3465                                    ASSERT = {
3458 3466                                            BINDING = WEAK;
3459 3467                                            ALIAS = sys_errlist;
3460 3468                                          };
3461 3469                                  };
3462 3470          _sys_errs               {
3463 3471                                    ASSERT = {
3464 3472                                            TYPE = OBJECT;
3465 3473                                            SIZE = 3216;
3466 3474                                          };
3467 3475                                  };
3468 3476          _sys_index              {
3469 3477                                    ASSERT = {
3470 3478                                            TYPE = OBJECT;
3471 3479                                            SIZE = 608;
3472 3480                                          };
3473 3481                                  };
3474 3482          _sys_nerr               {
3475 3483                                    FLAGS = NODYNSORT;
3476 3484                                    ASSERT = {
3477 3485                                            BINDING = WEAK;
3478 3486                                            ALIAS = _sys_num_err;
3479 3487                                          };
3480 3488                                  };
3481 3489          _sys_num_err            {
3482 3490                                    ASSERT = {
3483 3491                                            TYPE = OBJECT;
3484 3492                                            SIZE = 4;
3485 3493                                          };
3486 3494                                  };
3487 3495  $elif sparcv9
3488 3496          _dladdr                 {
3489 3497                                    TYPE = FUNCTION;
3490 3498                                    FILTER = /usr/lib/sparcv9/ld.so.1;
3491 3499                                  };
3492 3500          _dladdr1                {
3493 3501                                    TYPE = FUNCTION;
3494 3502                                    FILTER = /usr/lib/sparcv9/ld.so.1;
3495 3503                                  };
3496 3504          _dlclose                {
3497 3505                                    TYPE = FUNCTION;
3498 3506                                    FILTER = /usr/lib/sparcv9/ld.so.1;
3499 3507                                  };
3500 3508          _dldump                 {
3501 3509                                    TYPE = FUNCTION;
3502 3510                                    FILTER = /usr/lib/sparcv9/ld.so.1;
3503 3511                                  };
3504 3512          _dlerror                {
3505 3513                                    TYPE = FUNCTION;
3506 3514                                    FILTER = /usr/lib/sparcv9/ld.so.1;
3507 3515                                  };
3508 3516          _dlinfo                 {
3509 3517                                    TYPE = FUNCTION;
3510 3518                                    FILTER = /usr/lib/sparcv9/ld.so.1;
3511 3519                                  };
3512 3520          _dlmopen                {
3513 3521                                    TYPE = FUNCTION;
3514 3522                                    FILTER = /usr/lib/sparcv9/ld.so.1;
3515 3523                                  };
3516 3524          _dlopen                 {
3517 3525                                    TYPE = FUNCTION;
3518 3526                                    FILTER = /usr/lib/sparcv9/ld.so.1;
3519 3527                                  };
3520 3528          _dlsym                  {
3521 3529                                    TYPE = FUNCTION;
3522 3530                                    FILTER = /usr/lib/sparcv9/ld.so.1;
3523 3531                                  };
3524 3532          _ld_libc                {
3525 3533                                    TYPE = FUNCTION;
3526 3534                                    FILTER = /usr/lib/sparcv9/ld.so.1;
3527 3535                                  };
3528 3536  $elif amd64
3529 3537          _dladdr                 {
3530 3538                                    TYPE = FUNCTION;
3531 3539                                    FILTER = /usr/lib/amd64/ld.so.1;
3532 3540                                  };
3533 3541          _dladdr1                {
3534 3542                                    TYPE = FUNCTION;
3535 3543                                    FILTER = /usr/lib/amd64/ld.so.1;
3536 3544                                  };
3537 3545          _dlamd64getunwind       {
3538 3546                                    TYPE = FUNCTION;
3539 3547                                    FILTER = /usr/lib/amd64/ld.so.1;
3540 3548                                  };
3541 3549          _dlclose                {
3542 3550                                    TYPE = FUNCTION;
3543 3551                                    FILTER = /usr/lib/amd64/ld.so.1;
3544 3552                                  };
3545 3553          _dldump                 {
3546 3554                                    TYPE = FUNCTION;
3547 3555                                    FILTER = /usr/lib/amd64/ld.so.1;
3548 3556                                  };
3549 3557          _dlerror                {
3550 3558                                    TYPE = FUNCTION;
3551 3559                                    FILTER = /usr/lib/amd64/ld.so.1;
3552 3560                                  };
3553 3561          _dlinfo                 {
3554 3562                                    TYPE = FUNCTION;
3555 3563                                    FILTER = /usr/lib/amd64/ld.so.1;
3556 3564                                  };
3557 3565          _dlmopen                {
3558 3566                                    TYPE = FUNCTION;
3559 3567                                    FILTER = /usr/lib/amd64/ld.so.1;
3560 3568                                  };
3561 3569          _dlopen                 {
3562 3570                                    TYPE = FUNCTION;
3563 3571                                    FILTER = /usr/lib/amd64/ld.so.1;
3564 3572                                  };
3565 3573          _dlsym                  {
3566 3574                                    TYPE = FUNCTION;
3567 3575                                    FILTER = /usr/lib/amd64/ld.so.1;
3568 3576                                  };
3569 3577          _ld_libc                {
3570 3578                                    TYPE = FUNCTION;
3571 3579                                    FILTER = /usr/lib/amd64/ld.so.1;
3572 3580                                  };
3573 3581  $else
3574 3582  $error unknown platform
3575 3583  $endif
3576 3584  
3577 3585  $if _sparc
3578 3586          __lyday_to_month        {
3579 3587                                    ASSERT = {
3580 3588                                            TYPE = OBJECT;
3581 3589                                            SIZE = 48;
3582 3590                                          };
3583 3591                                  };
3584 3592          __mon_lengths           {
3585 3593                                    ASSERT = {
3586 3594                                            TYPE = OBJECT;
3587 3595                                            SIZE = 96;
3588 3596                                          };
3589 3597                                  };
3590 3598          __yday_to_month         {
3591 3599                                    ASSERT = {
3592 3600                                            TYPE = OBJECT;
3593 3601                                            SIZE = 48;
3594 3602                                          };
3595 3603                                  };
3596 3604  $endif
3597 3605  $if i386
3598 3606          _sse_hw                 {
3599 3607                                    ASSERT = {
3600 3608                                            TYPE = OBJECT;
3601 3609                                            SIZE = 4;
3602 3610                                          };
3603 3611                                  };
3604 3612  $endif
3605 3613  
3606 3614      protected:
3607 3615          acctctl;
3608 3616          allocids;
3609 3617          _assert_c99;
3610 3618          __assert_c99;
3611 3619          _assfail;
3612 3620          attr_count;
3613 3621          attr_to_data_type;
3614 3622          attr_to_name;
3615 3623          attr_to_option;
3616 3624          attr_to_xattr_view;
3617 3625          _autofssys;
3618 3626          _bufsync;
3619 3627          _cladm;
3620 3628          __class_quadruple;
3621 3629          core_get_default_content;
3622 3630          core_get_default_path;
3623 3631          core_get_global_content;
3624 3632          core_get_global_path;
3625 3633          core_get_options;
3626 3634          core_get_process_content;
3627 3635          core_get_process_path;
3628 3636          core_set_default_content;
3629 3637          core_set_default_path;
3630 3638          core_set_global_content;
3631 3639          core_set_global_path;
3632 3640          core_set_options;
3633 3641          core_set_process_content;
3634 3642          core_set_process_path;
3635 3643          dbm_close_status;
3636 3644          dbm_do_nextkey;
3637 3645          dbm_setdefwrite;
3638 3646          _D_cplx_div;
3639 3647          _D_cplx_div_ix;
3640 3648          _D_cplx_div_rx;
3641 3649          _D_cplx_mul;
3642 3650          defclose_r;
3643 3651          defcntl;
3644 3652          defcntl_r;
3645 3653          defopen;
3646 3654          defopen_r;
3647 3655          defread;
3648 3656          defread_r;
3649 3657          _delete;
3650 3658          _dgettext;
3651 3659          _doprnt;
3652 3660          _doscan;
3653 3661          _errfp;
3654 3662          _errxfp;
3655 3663          exportfs;
3656 3664          _F_cplx_div;
3657 3665          _F_cplx_div_ix;
3658 3666          _F_cplx_div_rx;
3659 3667          _F_cplx_mul;
3660 3668          __fgetwc_xpg5;
3661 3669          __fgetws_xpg5;
3662 3670          _findbuf;
3663 3671          _findiop;
3664 3672          __fini_daemon_priv;
3665 3673          _finite;
3666 3674          _fork1                  { FLAGS = NODYNSORT; };
3667 3675          _forkall                { FLAGS = NODYNSORT; };
3668 3676          _fpclass;
3669 3677          _fpgetmask;
3670 3678          _fpgetround;
3671 3679          _fpgetsticky;
3672 3680          _fprintf;
3673 3681          _fpsetmask;
3674 3682          _fpsetround;
3675 3683          _fpsetsticky;
3676 3684          __fputwc_xpg5;
3677 3685          __fputws_xpg5;
3678 3686          _ftw;
3679 3687          _gcvt;
3680 3688          _getarg;
3681 3689          __getcontext;
3682 3690          _getdents;
3683 3691          _get_exit_frame_monitor;
3684 3692          _getfp;
3685 3693          _getgroupsbymember;
3686 3694          _getlogin_r;
3687 3695          _getsp;
3688 3696          __gettsp;
3689 3697          getvmusage;
3690 3698          __getwchar_xpg5;
3691 3699          __getwc_xpg5;
3692 3700          gtty;
3693 3701          __idmap_flush_kcache;
3694 3702          __idmap_reg;
3695 3703          __idmap_unreg;
3696 3704          __init_daemon_priv;
3697 3705          __init_suid_priv;
3698 3706          inotify_init;
3699 3707          inotify_init1;
3700 3708          inotify_add_watch;
3701 3709          inotify_rm_watch;
3702 3710          _insert;
3703 3711          inst_sync;
3704 3712          _iswctype;
3705 3713          klpd_create;
3706 3714          klpd_getpath;
3707 3715          klpd_getport;
3708 3716          klpd_getucred;
3709 3717          klpd_register;
3710 3718          klpd_register_id;
3711 3719          klpd_unregister;
3712 3720          klpd_unregister_id;
3713 3721          _lgrp_home_fast         { FLAGS = NODYNSORT; };
3714 3722          _lgrpsys;
3715 3723          _lltostr;
3716 3724          _lock_clear;
3717 3725          _lock_try;
3718 3726          _ltzset;
3719 3727          lwp_self;
3720 3728          makeut;
3721 3729          makeutx;
3722 3730          _mbftowc;
3723 3731          mcfiller;
3724 3732          mntopt;
3725 3733          modctl;
3726 3734          modutx;
3727 3735          msgctl64;
3728 3736          __multi_innetgr;
3729 3737          _mutex_destroy          { FLAGS = NODYNSORT; };
3730 3738          mutex_enter;
3731 3739          mutex_exit;
3732 3740          mutex_held;
3733 3741          _mutex_init             { FLAGS = NODYNSORT; };
3734 3742          _mutex_unlock           { FLAGS = NODYNSORT; };
3735 3743          name_to_attr;
3736 3744          nfs_getfh;
3737 3745          nfssvc;
3738 3746          _nfssys;
3739 3747          __nis_get_environment;
3740 3748          _nss_db_state_destr;
3741 3749          nss_default_key2str;
3742 3750          nss_delete;
3743 3751          nss_endent;
3744 3752          nss_getent;
3745 3753          _nss_initf_group;
3746 3754          _nss_initf_netgroup;
3747 3755          _nss_initf_passwd;
3748 3756          _nss_initf_shadow;
3749 3757          nss_packed_arg_init;
3750 3758          nss_packed_context_init;
3751 3759          nss_packed_getkey;
3752 3760          nss_packed_set_status;
3753 3761          nss_search;
3754 3762          nss_setent;
3755 3763          _nss_XbyY_fgets;
3756 3764          _nss_XbyY_fini;
3757 3765          __nsw_extended_action_v1;
3758 3766          __nsw_freeconfig_v1;
3759 3767          __nsw_getconfig_v1;
3760 3768          __nthreads;
3761 3769          __openattrdirat;
3762 3770          option_to_attr;
3763 3771          __priv_bracket;
3764 3772          __priv_relinquish;
3765 3773          psecflags;
3766 3774          pset_assign_forced;
3767 3775          pset_bind_lwp;
3768 3776          _psignal;
3769 3777          pthread_attr_getdaemonstate_np;
3770 3778          pthread_attr_setdaemonstate_np;
3771 3779          pthread_mutex_enter_np;
3772 3780          pthread_mutex_exit_np;
3773 3781          _pthread_setcleanupinit;
3774 3782          __putwchar_xpg5;
3775 3783          __putwc_xpg5;
3776 3784          rctlctl;
3777 3785          rctllist;
3778 3786          _realbufend;
3779 3787          _resume;
3780 3788          _resume_ret;
3781 3789          _rpcsys;
3782 3790          _sbrk_grow_aligned;
3783 3791          scrwidth;
3784 3792          secflag_by_name;
3785 3793          secflag_clear;
3786 3794          secflags_copy;
3787 3795          secflags_difference;
3788 3796          secflags_fullset;
3789 3797          secflags_intersection;
3790 3798          secflags_isempty;
3791 3799          secflag_isset;
3792 3800          secflags_issubset;
3793 3801          secflags_issuperset;
3794 3802          secflag_set;
3795 3803          secflag_to_bit;
3796 3804          secflag_to_str;
3797 3805          secflags_union;
3798 3806          psecflags_validate_delta;
3799 3807          secflags_zero;
3800 3808          psecflags_default;
3801 3809          secflags_parse;
3802 3810          secflags_to_str;
3803 3811          psecflags_validate;
3804 3812          semctl64;
3805 3813          _semctl64;
3806 3814          set_escaped_context_cleanup;
3807 3815          set_setcontext_enforcement;
3808 3816          setcontext_sigmask;
3809 3817          _setbufend;
3810 3818          __set_errno;
3811 3819          setprojrctl;
3812 3820          _setregid;
3813 3821          _setreuid;
3814 3822          setsigacthandler;
3815 3823          shmctl64;
3816 3824          _shmctl64;
3817 3825          sigflag;
3818 3826          _signal;
3819 3827          _sigoff;
3820 3828          _sigon;
3821 3829          _so_accept;
3822 3830          _so_bind;
3823 3831          _sockconfig;
3824 3832          _so_connect;
3825 3833          _so_getpeername;
3826 3834          _so_getsockname;
3827 3835          _so_getsockopt;
3828 3836          _so_listen;
3829 3837          _so_recv;
3830 3838          _so_recvfrom;
3831 3839          _so_recvmsg;
3832 3840          _so_send;
3833 3841          _so_sendmsg;
3834 3842          _so_sendto;
3835 3843          _so_setsockopt;
3836 3844          _so_shutdown;
3837 3845          _so_socket;
3838 3846          _so_socketpair;
3839 3847          str2group;
3840 3848          str2passwd;
3841 3849          str2spwd;
3842 3850          __strptime_dontzero;
3843 3851          stty;
3844 3852          syscall;
3845 3853          _sysconfig;
3846 3854          __systemcall;
3847 3855          thr_continue_allmutators;
3848 3856          _thr_continue_allmutators;
3849 3857          thr_continue_mutator;
3850 3858          _thr_continue_mutator;
3851 3859          thr_getstate;
3852 3860          _thr_getstate;
3853 3861          thr_mutators_barrier;
3854 3862          _thr_mutators_barrier;
3855 3863          thr_probe_setup;
3856 3864          _thr_schedctl;
3857 3865          thr_setmutator;
3858 3866          _thr_setmutator;
3859 3867          thr_setstate;
3860 3868          _thr_setstate;
3861 3869          thr_sighndlrinfo;
3862 3870          _thr_sighndlrinfo;
3863 3871          _thr_slot_offset;
3864 3872          thr_suspend_allmutators;
3865 3873          _thr_suspend_allmutators;
3866 3874          thr_suspend_mutator;
3867 3875          _thr_suspend_mutator;
3868 3876          thr_wait_mutator;
3869 3877          _thr_wait_mutator;
3870 3878          __tls_get_addr;
3871 3879          _tmem_get_base;
3872 3880          _tmem_get_nentries;
3873 3881          _tmem_set_cleanup;
3874 3882          tpool_create;
3875 3883          tpool_dispatch;
3876 3884          tpool_destroy;
3877 3885          tpool_wait;
3878 3886          tpool_suspend;
3879 3887          tpool_suspended;
3880 3888          tpool_resume;
3881 3889          tpool_member;
3882 3890          _ttyname_dev;
3883 3891          _ucred_alloc;
3884 3892          ucred_getamask;
3885 3893          _ucred_getamask;
3886 3894          ucred_getasid;
3887 3895          _ucred_getasid;
3888 3896          ucred_getatid;
3889 3897          _ucred_getatid;
3890 3898          ucred_getauid;
3891 3899          _ucred_getauid;
3892 3900          _ulltostr;
3893 3901          _uncached_getgrgid_r;
3894 3902          _uncached_getgrnam_r;
3895 3903          _uncached_getpwnam_r;
3896 3904          _uncached_getpwuid_r;
3897 3905          __ungetwc_xpg5;
3898 3906          _unordered;
3899 3907          utssys;
3900 3908          _verrfp;
3901 3909          _verrxfp;
3902 3910          _vwarnfp;
3903 3911          _vwarnxfp;
3904 3912          _warnfp;
3905 3913          _warnxfp;
3906 3914          __wcsftime_xpg5;
3907 3915          __wcstok_xpg5;
3908 3916          wdbindf;
3909 3917          wdchkind;
3910 3918          wddelim;
3911 3919          _wrtchk;
3912 3920          _xflsbuf;
3913 3921          _xgetwidth;
3914 3922          zone_add_datalink;
3915 3923          zone_boot;
3916 3924          zone_check_datalink;
3917 3925          zone_create;
3918 3926          zone_destroy;
3919 3927          zone_enter;
3920 3928          zone_getattr;
3921 3929          zone_get_id;
3922 3930          zone_list;
3923 3931          zone_list_datalink;
3924 3932          zonept;
3925 3933          zone_get_nroot;
3926 3934          zone_remove_datalink;
3927 3935          zone_setattr;
3928 3936          zone_shutdown;
3929 3937          zone_version;
3930 3938  
3931 3939  $if _ELF32
3932 3940          __divdi3;
3933 3941          _file_set;
3934 3942          _fprintf_c89;
3935 3943          _fscanf_c89;
3936 3944          _fwprintf_c89;
3937 3945          _fwscanf_c89;
3938 3946          _imaxabs_c89;
3939 3947          _imaxdiv_c89;
3940 3948          __moddi3;
3941 3949          _printf_c89;
3942 3950          _scanf_c89;
3943 3951          _snprintf_c89;
3944 3952          _sprintf_c89;
3945 3953          _sscanf_c89;
3946 3954          _strtoimax_c89;
3947 3955          _strtoumax_c89;
3948 3956          _swprintf_c89;
3949 3957          _swscanf_c89;
3950 3958          __udivdi3;
3951 3959          __umoddi3;
3952 3960          _vfprintf_c89;
3953 3961          _vfscanf_c89;
3954 3962          _vfwprintf_c89;
3955 3963          _vfwscanf_c89;
3956 3964          _vprintf_c89;
3957 3965          _vscanf_c89;
3958 3966          _vsnprintf_c89;
3959 3967          _vsprintf_c89;
3960 3968          _vsscanf_c89;
3961 3969          _vswprintf_c89;
3962 3970          _vswscanf_c89;
3963 3971          _vwprintf_c89;
3964 3972          _vwscanf_c89;
3965 3973          _wcstoimax_c89;
3966 3974          _wcstoumax_c89;
3967 3975          _wprintf_c89;
3968 3976          _wscanf_c89;
3969 3977  $endif
3970 3978  
3971 3979  $if _sparc
3972 3980          _cerror;
3973 3981          install_utrap;
3974 3982          _install_utrap;
3975 3983          nop;
3976 3984          _Q_cplx_div;
3977 3985          _Q_cplx_div_ix;
3978 3986          _Q_cplx_div_rx;
3979 3987          _Q_cplx_lr_div;
3980 3988          _Q_cplx_lr_div_ix;
3981 3989          _Q_cplx_lr_div_rx;
3982 3990          _Q_cplx_lr_mul;
3983 3991          _Q_cplx_mul;
3984 3992          _QgetRD;
3985 3993          _xregs_clrptr;
3986 3994  $endif
3987 3995  
3988 3996  $if sparc32
3989 3997          __ashldi3;
3990 3998          __ashrdi3;
3991 3999          _cerror64;
3992 4000          __cmpdi2;
3993 4001          __floatdidf;
3994 4002          __floatdisf;
3995 4003          __floatundidf;
3996 4004          __floatundisf;
3997 4005          __lshrdi3;
3998 4006          __muldi3;
3999 4007          __ucmpdi2;
4000 4008  $endif
4001 4009  
4002 4010  $if sparcv9
4003 4011          __multi3;
4004 4012  $endif
4005 4013  
4006 4014  $if _x86
4007 4015          _D_cplx_lr_div;
4008 4016          _D_cplx_lr_div_ix;
4009 4017          _D_cplx_lr_div_rx;
4010 4018          _F_cplx_lr_div;
4011 4019          _F_cplx_lr_div_ix;
4012 4020          _F_cplx_lr_div_rx;
4013 4021          __fltrounds;
4014 4022          sysi86;
4015 4023          _sysi86;
4016 4024          _X_cplx_div;
4017 4025          _X_cplx_div_ix;
4018 4026          _X_cplx_div_rx;
4019 4027          _X_cplx_lr_div;
4020 4028          _X_cplx_lr_div_ix;
4021 4029          _X_cplx_lr_div_rx;
4022 4030          _X_cplx_mul;
4023 4031          __xgetRD;
4024 4032          __xtol;
4025 4033          __xtoll;
4026 4034          __xtoul;
4027 4035          __xtoull;
4028 4036  $endif
4029 4037  
4030 4038  $if i386
4031 4039          __divrem64;
4032 4040          ___tls_get_addr;
4033 4041          __udivrem64;
4034 4042  $endif
4035 4043  
4036 4044          # The following functions should not be exported from libc,
4037 4045          # but /lib/libm.so.2, some older versions of the Studio
4038 4046          # compiler/debugger components, and some ancient programs
4039 4047          # found in /usr/dist reference them.  When we no longer
4040 4048          # care about these old and broken binary objects, these
4041 4049          # symbols should be deleted.
4042 4050          _brk                                    { FLAGS = NODYNSORT; };
4043 4051          _cond_broadcast                         { FLAGS = NODYNSORT; };
4044 4052          _cond_init                              { FLAGS = NODYNSORT; };
4045 4053          _cond_signal                            { FLAGS = NODYNSORT; };
4046 4054          _cond_wait                              { FLAGS = NODYNSORT; };
4047 4055          _ecvt                                   { FLAGS = NODYNSORT; };
4048 4056          _fcvt                                   { FLAGS = NODYNSORT; };
4049 4057          _getc_unlocked                          { FLAGS = NODYNSORT; };
4050 4058          _llseek                                 { FLAGS = NODYNSORT; };
4051 4059          _pthread_attr_getdetachstate            { FLAGS = NODYNSORT; };
4052 4060          _pthread_attr_getinheritsched           { FLAGS = NODYNSORT; };
4053 4061          _pthread_attr_getschedparam             { FLAGS = NODYNSORT; };
4054 4062          _pthread_attr_getschedpolicy            { FLAGS = NODYNSORT; };
4055 4063          _pthread_attr_getscope                  { FLAGS = NODYNSORT; };
4056 4064          _pthread_attr_getstackaddr              { FLAGS = NODYNSORT; };
4057 4065          _pthread_attr_getstacksize              { FLAGS = NODYNSORT; };
4058 4066          _pthread_attr_init                      { FLAGS = NODYNSORT; };
4059 4067          _pthread_condattr_getpshared            { FLAGS = NODYNSORT; };
4060 4068          _pthread_condattr_init                  { FLAGS = NODYNSORT; };
4061 4069          _pthread_cond_init                      { FLAGS = NODYNSORT; };
4062 4070          _pthread_create                         { FLAGS = NODYNSORT; };
4063 4071          _pthread_getschedparam                  { FLAGS = NODYNSORT; };
4064 4072          _pthread_join                           { FLAGS = NODYNSORT; };
4065 4073          _pthread_key_create                     { FLAGS = NODYNSORT; };
4066 4074          _pthread_mutexattr_getprioceiling       { FLAGS = NODYNSORT; };
4067 4075          _pthread_mutexattr_getprotocol          { FLAGS = NODYNSORT; };
4068 4076          _pthread_mutexattr_getpshared           { FLAGS = NODYNSORT; };
4069 4077          _pthread_mutexattr_init                 { FLAGS = NODYNSORT; };
4070 4078          _pthread_mutex_getprioceiling           { FLAGS = NODYNSORT; };
4071 4079          _pthread_mutex_init                     { FLAGS = NODYNSORT; };
4072 4080          _pthread_sigmask                        { FLAGS = NODYNSORT; };
4073 4081          _rwlock_init                            { FLAGS = NODYNSORT; };
4074 4082          _rw_rdlock                              { FLAGS = NODYNSORT; };
4075 4083          _rw_unlock                              { FLAGS = NODYNSORT; };
4076 4084          _rw_wrlock                              { FLAGS = NODYNSORT; };
4077 4085          _sbrk_unlocked                          { FLAGS = NODYNSORT; };
4078 4086          _select                                 { FLAGS = NODYNSORT; };
4079 4087          _sema_init                              { FLAGS = NODYNSORT; };
4080 4088          _sema_post                              { FLAGS = NODYNSORT; };
4081 4089          _sema_trywait                           { FLAGS = NODYNSORT; };
4082 4090          _sema_wait                              { FLAGS = NODYNSORT; };
4083 4091          _sysfs                                  { FLAGS = NODYNSORT; };
4084 4092          _thr_create                             { FLAGS = NODYNSORT; };
4085 4093          _thr_exit                               { FLAGS = NODYNSORT; };
4086 4094          _thr_getprio                            { FLAGS = NODYNSORT; };
4087 4095          _thr_getspecific                        { FLAGS = NODYNSORT; };
4088 4096          _thr_join                               { FLAGS = NODYNSORT; };
4089 4097          _thr_keycreate                          { FLAGS = NODYNSORT; };
4090 4098          _thr_kill                               { FLAGS = NODYNSORT; };
4091 4099          _thr_main                               { FLAGS = NODYNSORT; };
4092 4100          _thr_self                               { FLAGS = NODYNSORT; };
4093 4101          _thr_setspecific                        { FLAGS = NODYNSORT; };
4094 4102          _thr_sigsetmask                         { FLAGS = NODYNSORT; };
4095 4103          _thr_stksegment                         { FLAGS = NODYNSORT; };
4096 4104          _ungetc_unlocked                        { FLAGS = NODYNSORT; };
4097 4105  
4098 4106      local:
4099 4107          _ti_thr_self                            { FLAGS = NODYNSORT; };
4100 4108          __imax_lldiv                            { FLAGS = NODYNSORT; };
4101 4109  
4102 4110          *;
4103 4111  $if lf64
4104 4112          _seekdir64              { FLAGS = NODYNSORT; };
4105 4113          _telldir64              { FLAGS = NODYNSORT; };
4106 4114  $endif
4107 4115  
4108 4116  $if _sparc
4109 4117          __cerror                { FLAGS = NODYNSORT; };
4110 4118  $endif
4111 4119  
4112 4120  $if sparc32
4113 4121          __cerror64              { FLAGS = NODYNSORT; };
4114 4122  $endif
4115 4123  
4116 4124  $if sparcv9
4117 4125          __cleanup               { FLAGS = NODYNSORT; };
4118 4126  $endif
4119 4127  
4120 4128  $if i386
4121 4129          _syscall6               { FLAGS = NODYNSORT; };
4122 4130          __systemcall6           { FLAGS = NODYNSORT; };
4123 4131  $endif
4124 4132  
4125 4133  $if amd64
4126 4134          ___tls_get_addr         { FLAGS = NODYNSORT; };
4127 4135  $endif
4128 4136  };
  
    | 
      ↓ open down ↓ | 
    4038 lines elided | 
    
      ↑ open up ↑ | 
  
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX