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