libphobos/libdruntime/core/sys/posix/setjmp.d

   1 /**
   2  * D header file for POSIX.
   3  *
   4  * Copyright: Copyright Sean Kelly 2005 - 2009.
   5  * License:   $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
   6  * Authors:   Sean Kelly
   7  * Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
   8  */
   9
  10 /*          Copyright Sean Kelly 2005 - 2009.
  11  * Distributed under the Boost Software License, Version 1.0.
  12  *    (See accompanying file LICENSE or copy at
  13  *          http://www.boost.org/LICENSE_1_0.txt)
  14  */
  15 module core.sys.posix.setjmp;
  16
  17 private import core.sys.posix.config;
  18 private import core.sys.posix.signal; // for sigset_t
  19
  20 version (Posix):
  21 extern (C) nothrow @nogc:
  22
  23 version (RISCV32) version = RISCV_Any;
  24 version (RISCV64) version = RISCV_Any;
  25
  26 //
  27 // Required
  28 //
  29 /*
  30 jmp_buf
  31
  32 int  setjmp(ref jmp_buf);
  33 void longjmp(ref jmp_buf, int);
  34 */
  35
  36 version (CRuntime_Glibc)
  37 {
  38     version (X86_64)
  39     {
  40         //enum JB_BX      = 0;
  41         //enum JB_BP      = 1;
  42         //enum JB_12      = 2;
  43         //enum JB_13      = 3;
  44         //enum JB_14      = 4;
  45         //enum JB_15      = 5;
  46         //enum JB_SP      = 6;
  47         //enum JB_PC      = 7;
  48         //enum JB_SIZE    = 64;
  49
  50         alias long[8] __jmp_buf;
  51     }
  52     else version (X86)
  53     {
  54         //enum JB_BX      = 0;
  55         //enum JB_SI      = 1;
  56         //enum JB_DI      = 2;
  57         //enum JB_BP      = 3;
  58         //enum JB_SP      = 4;
  59         //enum JB_PC      = 5;
  60         //enum JB_SIZE    = 24;
  61
  62         alias int[6] __jmp_buf;
  63     }
  64     else version (SPARC)
  65     {
  66         alias int[3] __jmp_buf;
  67     }
  68     else version (SPARC64)
  69     {
  70         alias __jmp_buf = ulong[22];
  71     }
  72     else version (AArch64)
  73     {
  74         alias long[22] __jmp_buf;
  75     }
  76     else version (ARM)
  77     {
  78         alias int[64] __jmp_buf;
  79     }
  80     else version (HPPA)
  81     {
  82         struct __jmp_buf
  83         {
  84             int __r3;
  85             int[15] __r4_r18;
  86             int __r19;
  87             int __r27;
  88             int __sp;
  89             int __rp;
  90             int __pad1;
  91             double[10] __fr12_fr21;
  92         }
  93     }
  94     else version (PPC)
  95     {
  96         alias int[64 + (12*4)] __jmp_buf;
  97     }
  98     else version (PPC64)
  99     {
 100         alias long[64] __jmp_buf;
 101     }
 102     else version (MIPS32)
 103     {
 104         struct __jmp_buf
 105         {
 106             version (MIPS_O32)
 107             {
 108                 void * __pc;
 109                 void * __sp;
 110                 int[8] __regs;
 111                 void * __fp;
 112                 void * __gp;
 113             }
 114             else
 115             {
 116                 long __pc;
 117                 long __sp;
 118                 long[8] __regs;
 119                 long __fp;
 120                 long __gp;
 121             }
 122             int __fpc_csr;
 123             version (MIPS_N64)
 124                 double[8] __fpregs;
 125             else
 126                 double[6] __fpregs;
 127         }
 128     }
 129     else version (MIPS64)
 130     {
 131         struct __jmp_buf
 132         {
 133             long __pc;
 134             long __sp;
 135             long[8] __regs;
 136             long __fp;
 137             long __gp;
 138             int __fpc_csr;
 139             version (MIPS_N64)
 140                 double[8] __fpregs;
 141             else
 142                 double[6] __fpregs;
 143         }
 144     }
 145     else version (RISCV_Any)
 146     {
 147         struct __riscv_jmp_buf
 148         {
 149             c_long __pc;
 150             c_long[12] __regs;
 151             c_long __sp;
 152             double[12] __fpregs;
 153         }
 154         alias __jmp_buf = __riscv_jmp_buf[1];
 155     }
 156     else version (S390)
 157     {
 158         struct __s390_jmp_buf
 159         {
 160             c_long[10] __gregs;
 161             c_long[4] __fpregs;
 162         }
 163         alias __jmp_buf = __s390_jmp_buf[1];
 164     }
 165     else version (SystemZ)
 166     {
 167         struct __s390_jmp_buf
 168         {
 169             c_long[10] __gregs;
 170             c_long[8] __fpregs;
 171         }
 172         alias __jmp_buf = __s390_jmp_buf[1];
 173     }
 174     else
 175         static assert(0, "unimplemented");
 176
 177     struct __jmp_buf_tag
 178     {
 179         __jmp_buf   __jmpbuf;
 180         int         __mask_was_saved;
 181         sigset_t    __saved_mask;
 182     }
 183
 184     alias __jmp_buf_tag[1] jmp_buf;
 185
 186     alias _setjmp setjmp; // see XOpen block
 187     void longjmp(ref jmp_buf, int);
 188 }
 189 else version (FreeBSD)
 190 {
 191     // <machine/setjmp.h>
 192     version (X86)
 193     {
 194         enum _JBLEN = 11;
 195         struct _jmp_buf { int[_JBLEN + 1] _jb; }
 196     }
 197     else version (X86_64)
 198     {
 199         enum _JBLEN = 12;
 200         struct _jmp_buf { c_long[_JBLEN] _jb; }
 201     }
 202     else version (SPARC)
 203     {
 204         enum _JBLEN = 5;
 205         struct _jmp_buf { c_long[_JBLEN + 1] _jb; }
 206     }
 207     else version (AArch64)
 208     {
 209         enum _JBLEN = 31;
 210         // __int128_t
 211         struct _jmp_buf { long[2][_JBLEN + 1] _jb; };
 212     }
 213     else
 214         static assert(0);
 215     alias _jmp_buf[1] jmp_buf;
 216
 217     int  setjmp(ref jmp_buf);
 218     void longjmp(ref jmp_buf, int);
 219 }
 220 else version (NetBSD)
 221 {
 222     // <machine/setjmp.h>
 223     version (X86)
 224     {
 225         enum _JBLEN = 13;
 226         struct _jmp_buf { int[_JBLEN + 1] _jb; }
 227     }
 228     else version (X86_64)
 229     {
 230         enum _JBLEN = 11;
 231         struct _jmp_buf { c_long[_JBLEN] _jb; }
 232     }
 233     else
 234         static assert(0);
 235     alias _jmp_buf[_JBLEN] jmp_buf;
 236
 237     int  setjmp(ref jmp_buf);
 238     void longjmp(ref jmp_buf, int);
 239 }
 240 else version (OpenBSD)
 241 {
 242     // <machine/setjmp.h>
 243     version (X86)
 244     {
 245         enum _JBLEN = 10;
 246     }
 247     else version (X86_64)
 248     {
 249         enum _JBLEN = 11;
 250     }
 251     else version (ARM)
 252     {
 253         enum _JBLEN = 64;
 254     }
 255     else version (PPC)
 256     {
 257         enum _JBLEN = 100;
 258     }
 259     else version (MIPS64)
 260     {
 261         enum _JBLEN = 83;
 262     }
 263     else version (SPARC)
 264     {
 265         enum _JBLEN = 10;
 266     }
 267     else version (SPARC64)
 268     {
 269         enum _JBLEN = 14;
 270     }
 271     else
 272         static assert(0);
 273
 274     alias jmp_buf = c_long[_JBLEN];
 275
 276     int  setjmp(ref jmp_buf);
 277     void longjmp(ref jmp_buf, int);
 278 }
 279 else version (DragonFlyBSD)
 280 {
 281     // <machine/setjmp.h>
 282     version (X86_64)
 283     {
 284         enum _JBLEN = 12;
 285         struct _jmp_buf { c_long[_JBLEN] _jb; }
 286     }
 287     else
 288         static assert(0);
 289     alias _jmp_buf[1] jmp_buf;
 290
 291     int  setjmp(ref jmp_buf);
 292     void longjmp(ref jmp_buf, int);
 293 }
 294 else version (CRuntime_Bionic)
 295 {
 296     // <machine/setjmp.h>
 297     version (X86)
 298     {
 299         enum _JBLEN = 10;
 300     }
 301     else version (ARM)
 302     {
 303         enum _JBLEN = 64;
 304     }
 305     else version (AArch64)
 306     {
 307         enum _JBLEN = 32;
 308     }
 309     else version (X86_64)
 310     {
 311         enum _JBLEN = 11;
 312     }
 313     else
 314     {
 315         static assert(false, "Architecture not supported.");
 316     }
 317
 318     alias c_long[_JBLEN] jmp_buf;
 319
 320     int  setjmp(ref jmp_buf);
 321     void longjmp(ref jmp_buf, int);
 322 }
 323 else version (CRuntime_UClibc)
 324 {
 325     version (X86_64)
 326     {
 327         alias long[8] __jmp_buf;
 328     }
 329     else version (ARM)
 330     {
 331         align(8) alias int[64] __jmp_buf;
 332     }
 333     else version (MIPS32)
 334     {
 335         struct __jmp_buf
 336         {
 337             version (MIPS_O32)
 338             {
 339                 void * __pc;
 340                 void * __sp;
 341                 int[8] __regs;
 342                 void * __fp;
 343                 void * __gp;
 344             }
 345             else
 346             {
 347                 long __pc;
 348                 long __sp;
 349                 long[8] __regs;
 350                 long __fp;
 351                 long __gp;
 352             }
 353             int __fpc_csr;
 354             version (MIPS_N64)
 355                 double[8] __fpregs;
 356             else
 357                 double[6] __fpregs;
 358         };
 359     }
 360     else
 361         static assert(0, "unimplemented");
 362
 363     struct __jmp_buf_tag
 364     {
 365         __jmp_buf   __jmpbuf;
 366         int         __mask_was_saved;
 367         sigset_t    __saved_mask;
 368     }
 369
 370     alias __jmp_buf_tag[1] jmp_buf;
 371
 372     alias _setjmp setjmp;
 373     void longjmp(ref jmp_buf, int);
 374 }
 375
 376 //
 377 // C Extension (CX)
 378 //
 379 /*
 380 sigjmp_buf
 381
 382 int  sigsetjmp(sigjmp_buf, int);
 383 void siglongjmp(sigjmp_buf, int);
 384 */
 385
 386 version (CRuntime_Glibc)
 387 {
 388     alias jmp_buf sigjmp_buf;
 389
 390     int __sigsetjmp(sigjmp_buf, int);
 391     alias __sigsetjmp sigsetjmp;
 392     void siglongjmp(sigjmp_buf, int);
 393 }
 394 else version (FreeBSD)
 395 {
 396     // <machine/setjmp.h>
 397     version (X86)
 398     {
 399         struct _sigjmp_buf { int[_JBLEN + 1] _ssjb; }
 400     }
 401     else version (X86_64)
 402     {
 403         struct _sigjmp_buf { c_long[_JBLEN] _sjb; }
 404     }
 405     else version (SPARC)
 406     {
 407         enum _JBLEN         = 5;
 408         enum _JB_FP         = 0;
 409         enum _JB_PC         = 1;
 410         enum _JB_SP         = 2;
 411         enum _JB_SIGMASK    = 3;
 412         enum _JB_SIGFLAG    = 5;
 413         struct _sigjmp_buf { c_long[_JBLEN + 1] _sjb; }
 414     }
 415     else version (AArch64)
 416     {
 417         // __int128_t
 418         struct _sigjmp_buf { long[2][_JBLEN + 1] _jb; };
 419     }
 420     else
 421         static assert(0);
 422     alias _sigjmp_buf[1] sigjmp_buf;
 423
 424     int  sigsetjmp(ref sigjmp_buf);
 425     void siglongjmp(ref sigjmp_buf, int);
 426 }
 427 else version (NetBSD)
 428 {
 429     // <machine/setjmp.h>
 430     version (X86)
 431     {
 432         struct _sigjmp_buf { int[_JBLEN + 1] _ssjb; }
 433     }
 434     else version (X86_64)
 435     {
 436         struct _sigjmp_buf { c_long[_JBLEN] _sjb; }
 437     }
 438     else
 439         static assert(0);
 440     alias _sigjmp_buf[_JBLEN + 1] sigjmp_buf;
 441
 442     int  sigsetjmp(ref sigjmp_buf);
 443     void siglongjmp(ref sigjmp_buf, int);
 444 }
 445 else version (OpenBSD)
 446 {
 447     alias sigjmp_buf = c_long[_JBLEN + 1];
 448
 449     int  sigsetjmp(ref sigjmp_buf);
 450     void siglongjmp(ref sigjmp_buf, int);
 451 }
 452 else version (DragonFlyBSD)
 453 {
 454     // <machine/setjmp.h>
 455     version (X86_64)
 456     {
 457         struct _sigjmp_buf { c_long[_JBLEN] _sjb; }
 458     }
 459     else
 460         static assert(0);
 461     alias _sigjmp_buf[1] sigjmp_buf;
 462
 463     int  sigsetjmp(ref sigjmp_buf);
 464     void siglongjmp(ref sigjmp_buf, int);
 465 }
 466 else version (CRuntime_Bionic)
 467 {
 468     alias c_long[_JBLEN + 1] sigjmp_buf;
 469
 470     int  sigsetjmp(ref sigjmp_buf, int);
 471     void siglongjmp(ref sigjmp_buf, int);
 472 }
 473 else version (CRuntime_UClibc)
 474 {
 475     alias jmp_buf sigjmp_buf;
 476
 477     int __sigsetjmp(ref sigjmp_buf, int);
 478     alias __sigsetjmp sigsetjmp;
 479     void siglongjmp(ref sigjmp_buf, int);
 480 }
 481
 482 //
 483 // XOpen (XSI)
 484 //
 485 /*
 486 int  _setjmp(jmp_buf);
 487 void _longjmp(jmp_buf, int);
 488 */
 489
 490 version (CRuntime_Glibc)
 491 {
 492     int  _setjmp(ref jmp_buf);
 493     void _longjmp(ref jmp_buf, int);
 494 }
 495 else version (FreeBSD)
 496 {
 497     int  _setjmp(ref jmp_buf);
 498     void _longjmp(ref jmp_buf, int);
 499 }
 500 else version (NetBSD)
 501 {
 502     int  _setjmp(ref jmp_buf);
 503     void _longjmp(ref jmp_buf, int);
 504 }
 505 else version (OpenBSD)
 506 {
 507     int  _setjmp(ref jmp_buf);
 508     void _longjmp(ref jmp_buf, int);
 509 }
 510 else version (DragonFlyBSD)
 511 {
 512     int  _setjmp(ref jmp_buf);
 513     void _longjmp(ref jmp_buf, int);
 514 }
 515 else version (CRuntime_Bionic)
 516 {
 517     int  _setjmp(ref jmp_buf);
 518     void _longjmp(ref jmp_buf, int);
 519 }
 520 else version (CRuntime_UClibc)
 521 {
 522     int  _setjmp(ref jmp_buf);
 523     void _longjmp(ref jmp_buf, int);
 524 }