1  /* We ensure that -Wpedantic is off since it complains about the trampolines
       2     we explicitly want to test.  */
       3  /* { dg-additional-options "-mharden-sls=retbr -Wno-pedantic " } */
       4  /*
       5     Ensure that the SLS hardening of RET and BR leaves no unprotected RET/BR
       6     instructions.
       7    */
       8  typedef int (foo) (int, int);
       9  typedef void (bar) (int, int);
      10  struct sls_testclass {
      11      foo *x;
      12      bar *y;
      13      int left;
      14      int right;
      15  };
      16  
      17  int
      18  retbr_sibcall_value_insn (struct sls_testclass x)
      19  {
      20    return x.x(x.left, x.right);
      21  }
      22  
      23  void
      24  retbr_sibcall_insn (struct sls_testclass x)
      25  {
      26    x.y(x.left, x.right);
      27  }
      28  
      29  /* Aim to test two different returns.
      30     One that introduces a tail call in the middle of the function, and one that
      31     has a normal return.  */
      32  int
      33  retbr_multiple_returns (struct sls_testclass x)
      34  {
      35    int temp;
      36    if (x.left % 10)
      37      return x.x(x.left, 100);
      38    else if (x.right % 20)
      39      {
      40        return x.x(x.left * x.right, 100);
      41      }
      42    temp = x.left % x.right;
      43    temp *= 100;
      44    temp /= 2;
      45    return temp % 3;
      46  }
      47  
      48  void
      49  retbr_multiple_returns_void (struct sls_testclass x)
      50  {
      51    if (x.left % 10)
      52      {
      53        x.y(x.left, 100);
      54      }
      55    else if (x.right % 20)
      56      {
      57        x.y(x.left * x.right, 100);
      58      }
      59    return;
      60  }
      61  
      62  /* Testing the casesi jump via register.  */
      63  __attribute__ ((optimize ("Os")))
      64  int
      65  retbr_casesi_dispatch (struct sls_testclass x)
      66  {
      67    switch (x.left)
      68      {
      69      case -5:
      70        return -2;
      71      case -3:
      72        return -1;
      73      case 0:
      74        return 0;
      75      case 3:
      76        return 1;
      77      case 5:
      78        break;
      79      default:
      80        __builtin_unreachable ();
      81      }
      82    return x.right;
      83  }
      84  
      85  /* Testing the BR in trampolines is mitigated against.  */
      86  void f1 (void *);
      87  void f3 (void *, void (*)(void *));
      88  void f2 (void *);
      89  
      90  int
      91  retbr_trampolines (void *a, int b)
      92  {
      93    if (!b)
      94      {
      95        f1 (a);
      96        return 1;
      97      }
      98    if (b)
      99      {
     100        void retbr_tramp_internal (void *c)
     101        {
     102  	if (c == a)
     103  	  f2 (c);
     104        }
     105        f3 (a, retbr_tramp_internal);
     106      }
     107    return 0;
     108  }
     109  
     110  /* Testing the indirect_jump pattern.  */
     111  void
     112  retbr_indirect_jump (int *buf)
     113  {
     114    __builtin_longjmp(buf, 1);
     115  }
     116  
     117  /* Ensure there are no BR or RET instructions which are not directly followed
     118     by a speculation barrier.  */
     119  /* { dg-final { scan-assembler-not {\t(br|ret|retaa|retab)\tx[0-9][0-9]?\n\t(?!dsb\tsy\n\tisb|sb)} } } */