11.2.0/include/sgxintrin.h

/* Copyright (C) 2017-2021 Free Software Foundation, Inc.

   This file is part of GCC.

   GCC is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, or (at your option)
   any later version.

   GCC is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   Under Section 7 of GPL version 3, you are granted additional
   permissions described in the GCC Runtime Library Exception, version
   3.1, as published by the Free Software Foundation.

   You should have received a copy of the GNU General Public License and
   a copy of the GCC Runtime Library Exception along with this program;
   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
   <http://www.gnu.org/licenses/>.  */

#ifndef _SGXINTRIN_H_INCLUDED
#define _SGXINTRIN_H_INCLUDED

#ifndef __SGX__
#pragma GCC push_options
#pragma GCC target("sgx")
#define __DISABLE_SGX__
#endif /* __SGX__ */

#define __encls_bc(leaf, b, c, retval)                  \
  __asm__ __volatile__ ("encls\n\t"                     \
           : "=a" (retval)                              \
           : "a" (leaf), "b" (b), "c" (c)               \
           : "cc")

#define __encls_bcd(leaf, b, c, d, retval)              \
  __asm__ __volatile__("encls\n\t"                      \
           : "=a" (retval)                              \
           : "a" (leaf), "b" (b), "c" (c), "d" (d)      \
           : "cc")

#define __encls_c(leaf, c, retval)                      \
  __asm__ __volatile__("encls\n\t"                      \
           : "=a" (retval)                              \
           : "a" (leaf), "c" (c)                        \
           : "cc")

#define __encls_edbgrd(leaf, b, c, retval)              \
  __asm__ __volatile__("encls\n\t"                      \
           : "=a" (retval), "=b" (b)                    \
           : "a" (leaf), "c" (c))

#define __encls_generic(leaf, b, c, d, retval)          \
  __asm__ __volatile__("encls\n\t"                      \
           : "=a" (retval), "=b" (b), "=c" (c), "=d" (d)\
           : "a" (leaf), "b" (b), "c" (c), "d" (d)      \
           : "cc")

#define __enclu_bc(leaf, b, c, retval)                  \
  __asm__ __volatile__("enclu\n\t"                      \
           : "=a" (retval)                              \
           : "a" (leaf), "b" (b), "c" (c)               \
           : "cc")

#define __enclu_bcd(leaf, b, c, d, retval)              \
  __asm__ __volatile__("enclu\n\t"                      \
           : "=a" (retval)                              \
           : "a" (leaf), "b" (b), "c" (c), "d" (d)      \
           : "cc")

#define __enclu_eenter(leaf, b, c, retval)              \
  __asm__  __volatile__("enclu\n\t"                     \
           : "=a" (retval), "=c" (c)                    \
           : "a" (leaf), "b" (b), "c" (c)               \
           : "cc")

#define __enclu_eexit(leaf, b, c, retval)               \
  __asm__  __volatile__("enclu\n\t"                     \
           : "=a" (retval), "=c" (c)                    \
           : "a" (leaf), "b" (b)                        \
           : "cc")

#define __enclu_generic(leaf, b, c, d, retval)          \
  __asm__ __volatile__("enclu\n\t"                      \
           : "=a" (retval), "=b" (b), "=c" (c), "=d" (d)\
           : "a" (leaf), "b" (b), "c" (c), "d" (d)      \
           : "cc")

#define __enclv_bc(leaf, b, c, retval)                  \
  __asm__ __volatile__("enclv\n\t"                      \
           : "=a" (retval)                              \
           : "a" (leaf), "b" (b), "c" (c)               \
           : "cc")

#define __enclv_cd(leaf, c, d, retval)                  \
  __asm__ __volatile__("enclv\n\t"                      \
           : "=a" (retval)                              \
           : "a" (leaf), "c" (c), "d" (d)               \
           : "cc")

#define __enclv_generic(leaf, b, c, d, retval)          \
  __asm__ __volatile__("enclv\n\t"                      \
           : "=a" (retval), "=b" (b), "=c" (b), "=d" (d)\
           : "a" (leaf), "b" (b), "c" (c), "d" (d)      \
           : "cc")

extern __inline unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_encls_u32 (const unsigned int __L, size_t __D[])
{
  enum __encls_type
  {
    __SGX_ECREATE = 0x00,
    __SGX_EADD    = 0x01,
    __SGX_EINIT   = 0x02,
    __SGX_EREMOVE = 0x03,
    __SGX_EDBGRD  = 0x04,
    __SGX_EDBGWR  = 0x05,
    __SGX_EEXTEND = 0x06,
    __SGX_ELDB    = 0x07,
    __SGX_ELDU    = 0x08,
    __SGX_EBLOCK  = 0x09,
    __SGX_EPA     = 0x0A,
    __SGX_EWB     = 0x0B,
    __SGX_ETRACK  = 0x0C,
    __SGX_EAUG    = 0x0D,
    __SGX_EMODPR  = 0x0E,
    __SGX_EMODT   = 0x0F,
    __SGX_ERDINFO = 0x10,
    __SGX_ETRACKC = 0x11,
    __SGX_ELDBC   = 0x12,
    __SGX_ELDUC   = 0x13
  };
  enum __encls_type __T = (enum __encls_type)__L;
  unsigned int __R = 0;
  if (!__builtin_constant_p (__T))
    __encls_generic (__L, __D[0], __D[1], __D[2], __R);
  else switch (__T)
    {
    case __SGX_ECREATE:
    case __SGX_EADD:
    case __SGX_EDBGWR:
    case __SGX_EEXTEND:
    case __SGX_EPA:
    case __SGX_EMODPR:
    case __SGX_EMODT:
    case __SGX_EAUG:
    case __SGX_ERDINFO:
      __encls_bc (__L, __D[0], __D[1], __R);
      break;
    case __SGX_EINIT:
    case __SGX_ELDB:
    case __SGX_ELDU:
    case __SGX_EWB:
    case __SGX_ELDBC:
    case __SGX_ELDUC:
      __encls_bcd (__L, __D[0], __D[1], __D[2], __R);
      break;
    case __SGX_EREMOVE:
    case __SGX_EBLOCK:
    case __SGX_ETRACK:
    case __SGX_ETRACKC:
      __encls_c (__L, __D[1], __R);
      break;
    case __SGX_EDBGRD:
      __encls_edbgrd (__L, __D[0], __D[1], __R);
      break;
    default:
      __encls_generic (__L, __D[0], __D[1], __D[2], __R);
    }
  return __R;
}

extern __inline unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_enclu_u32 (const unsigned int __L, size_t __D[])
{
  enum __enclu_type
  {
    __SGX_EREPORT     = 0x00,
    __SGX_EGETKEY     = 0x01,
    __SGX_EENTER      = 0x02,
    __SGX_ERESUME     = 0x03,
    __SGX_EEXIT       = 0x04,
    __SGX_EACCEPT     = 0x05,
    __SGX_EMODPE      = 0x06,
    __SGX_EACCEPTCOPY = 0x07
  };
  enum __enclu_type __T = (enum __enclu_type) __L;
  unsigned int __R = 0;
  if (!__builtin_constant_p (__T))
    __enclu_generic (__L, __D[0], __D[1], __D[2], __R);
  else switch (__T)
    {
    case __SGX_EREPORT:
    case __SGX_EACCEPTCOPY:
      __enclu_bcd (__L, __D[0], __D[1], __D[2], __R);
      break;
    case __SGX_EGETKEY:
    case __SGX_ERESUME:
    case __SGX_EACCEPT:
    case __SGX_EMODPE:
      __enclu_bc (__L, __D[0], __D[1], __R);
      break;
    case __SGX_EENTER:
      __enclu_eenter (__L, __D[0], __D[1], __R);
      break;
    case __SGX_EEXIT:
      __enclu_eexit (__L, __D[0], __D[1], __R);
      break;
    default:
      __enclu_generic (__L, __D[0], __D[1], __D[2], __R);
    }
  return __R;
}

extern __inline unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_enclv_u32 (const unsigned int __L, size_t __D[])
{
  enum __enclv_type
  {
    __SGX_EDECVIRTCHILD = 0x00,
    __SGX_EINCVIRTCHILD = 0x01,
    __SGX_ESETCONTEXT   = 0x02
  };
  unsigned int __R = 0;
  if (!__builtin_constant_p (__L))
    __enclv_generic (__L, __D[0], __D[1], __D[2], __R);
  else switch (__L)
    {
    case __SGX_EDECVIRTCHILD:
    case __SGX_EINCVIRTCHILD:
      __enclv_bc (__L, __D[0], __D[1], __R);
      break;
    case __SGX_ESETCONTEXT:
      __enclv_cd (__L, __D[1], __D[2], __R);
      break;
    default:
      __enclv_generic (__L, __D[0], __D[1], __D[2], __R);
    }
  return __R;
}

#ifdef __DISABLE_SGX__
#undef __DISABLE_SGX__
#pragma GCC pop_options
#endif /* __DISABLE_SGX__ */

#endif /* _SGXINTRIN_H_INCLUDED */
Revision:	1166
Committed:	Tue Oct 26 14:22:36 2021 UTC (4 years ago) by rossy
Content type:	text/x-chdr
File size:	7091 byte(s)
Log Message:	Daodan: Replace MinGW build env with an up-to-date MSYS2 env
#	Content
1	/* Copyright (C) 2017-2021 Free Software Foundation, Inc.
2
3	This file is part of GCC.
4
5	GCC is free software; you can redistribute it and/or modify
6	it under the terms of the GNU General Public License as published by
7	the Free Software Foundation; either version 3, or (at your option)
8	any later version.
9
10	GCC is distributed in the hope that it will be useful,
11	but WITHOUT ANY WARRANTY; without even the implied warranty of
12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	GNU General Public License for more details.
14
15	Under Section 7 of GPL version 3, you are granted additional
16	permissions described in the GCC Runtime Library Exception, version
17	3.1, as published by the Free Software Foundation.
18
19	You should have received a copy of the GNU General Public License and
20	a copy of the GCC Runtime Library Exception along with this program;
21	see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
22	<http://www.gnu.org/licenses/>. */
23
24	#ifndef _SGXINTRIN_H_INCLUDED
25	#define _SGXINTRIN_H_INCLUDED
26
27	#ifndef __SGX__
28	#pragma GCC push_options
29	#pragma GCC target("sgx")
30	#define __DISABLE_SGX__
31	#endif /* __SGX__ */
32
33	#define __encls_bc(leaf, b, c, retval) \
34	__asm__ __volatile__ ("encls\n\t" \
35	: "=a" (retval) \
36	: "a" (leaf), "b" (b), "c" (c) \
37	: "cc")
38
39	#define __encls_bcd(leaf, b, c, d, retval) \
40	__asm__ __volatile__("encls\n\t" \
41	: "=a" (retval) \
42	: "a" (leaf), "b" (b), "c" (c), "d" (d) \
43	: "cc")
44
45	#define __encls_c(leaf, c, retval) \
46	__asm__ __volatile__("encls\n\t" \
47	: "=a" (retval) \
48	: "a" (leaf), "c" (c) \
49	: "cc")
50
51	#define __encls_edbgrd(leaf, b, c, retval) \
52	__asm__ __volatile__("encls\n\t" \
53	: "=a" (retval), "=b" (b) \
54	: "a" (leaf), "c" (c))
55
56	#define __encls_generic(leaf, b, c, d, retval) \
57	__asm__ __volatile__("encls\n\t" \
58	: "=a" (retval), "=b" (b), "=c" (c), "=d" (d)\
59	: "a" (leaf), "b" (b), "c" (c), "d" (d) \
60	: "cc")
61
62	#define __enclu_bc(leaf, b, c, retval) \
63	__asm__ __volatile__("enclu\n\t" \
64	: "=a" (retval) \
65	: "a" (leaf), "b" (b), "c" (c) \
66	: "cc")
67
68	#define __enclu_bcd(leaf, b, c, d, retval) \
69	__asm__ __volatile__("enclu\n\t" \
70	: "=a" (retval) \
71	: "a" (leaf), "b" (b), "c" (c), "d" (d) \
72	: "cc")
73
74	#define __enclu_eenter(leaf, b, c, retval) \
75	__asm__ __volatile__("enclu\n\t" \
76	: "=a" (retval), "=c" (c) \
77	: "a" (leaf), "b" (b), "c" (c) \
78	: "cc")
79
80	#define __enclu_eexit(leaf, b, c, retval) \
81	__asm__ __volatile__("enclu\n\t" \
82	: "=a" (retval), "=c" (c) \
83	: "a" (leaf), "b" (b) \
84	: "cc")
85
86	#define __enclu_generic(leaf, b, c, d, retval) \
87	__asm__ __volatile__("enclu\n\t" \
88	: "=a" (retval), "=b" (b), "=c" (c), "=d" (d)\
89	: "a" (leaf), "b" (b), "c" (c), "d" (d) \
90	: "cc")
91
92	#define __enclv_bc(leaf, b, c, retval) \
93	__asm__ __volatile__("enclv\n\t" \
94	: "=a" (retval) \
95	: "a" (leaf), "b" (b), "c" (c) \
96	: "cc")
97
98	#define __enclv_cd(leaf, c, d, retval) \
99	__asm__ __volatile__("enclv\n\t" \
100	: "=a" (retval) \
101	: "a" (leaf), "c" (c), "d" (d) \
102	: "cc")
103
104	#define __enclv_generic(leaf, b, c, d, retval) \
105	__asm__ __volatile__("enclv\n\t" \
106	: "=a" (retval), "=b" (b), "=c" (b), "=d" (d)\
107	: "a" (leaf), "b" (b), "c" (c), "d" (d) \
108	: "cc")
109
110	extern __inline unsigned int
111	__attribute__((__gnu_inline__, __always_inline__, __artificial__))
112	_encls_u32 (const unsigned int __L, size_t __D[])
113	{
114	enum __encls_type
115	{
116	__SGX_ECREATE = 0x00,
117	__SGX_EADD = 0x01,
118	__SGX_EINIT = 0x02,
119	__SGX_EREMOVE = 0x03,
120	__SGX_EDBGRD = 0x04,
121	__SGX_EDBGWR = 0x05,
122	__SGX_EEXTEND = 0x06,
123	__SGX_ELDB = 0x07,
124	__SGX_ELDU = 0x08,
125	__SGX_EBLOCK = 0x09,
126	__SGX_EPA = 0x0A,
127	__SGX_EWB = 0x0B,
128	__SGX_ETRACK = 0x0C,
129	__SGX_EAUG = 0x0D,
130	__SGX_EMODPR = 0x0E,
131	__SGX_EMODT = 0x0F,
132	__SGX_ERDINFO = 0x10,
133	__SGX_ETRACKC = 0x11,
134	__SGX_ELDBC = 0x12,
135	__SGX_ELDUC = 0x13
136	};
137	enum __encls_type __T = (enum __encls_type)__L;
138	unsigned int __R = 0;
139	if (!__builtin_constant_p (__T))
140	__encls_generic (__L, __D[0], __D[1], __D[2], __R);
141	else switch (__T)
142	{
143	case __SGX_ECREATE:
144	case __SGX_EADD:
145	case __SGX_EDBGWR:
146	case __SGX_EEXTEND:
147	case __SGX_EPA:
148	case __SGX_EMODPR:
149	case __SGX_EMODT:
150	case __SGX_EAUG:
151	case __SGX_ERDINFO:
152	__encls_bc (__L, __D[0], __D[1], __R);
153	break;
154	case __SGX_EINIT:
155	case __SGX_ELDB:
156	case __SGX_ELDU:
157	case __SGX_EWB:
158	case __SGX_ELDBC:
159	case __SGX_ELDUC:
160	__encls_bcd (__L, __D[0], __D[1], __D[2], __R);
161	break;
162	case __SGX_EREMOVE:
163	case __SGX_EBLOCK:
164	case __SGX_ETRACK:
165	case __SGX_ETRACKC:
166	__encls_c (__L, __D[1], __R);
167	break;
168	case __SGX_EDBGRD:
169	__encls_edbgrd (__L, __D[0], __D[1], __R);
170	break;
171	default:
172	__encls_generic (__L, __D[0], __D[1], __D[2], __R);
173	}
174	return __R;
175	}
176
177	extern __inline unsigned int
178	__attribute__((__gnu_inline__, __always_inline__, __artificial__))
179	_enclu_u32 (const unsigned int __L, size_t __D[])
180	{
181	enum __enclu_type
182	{
183	__SGX_EREPORT = 0x00,
184	__SGX_EGETKEY = 0x01,
185	__SGX_EENTER = 0x02,
186	__SGX_ERESUME = 0x03,
187	__SGX_EEXIT = 0x04,
188	__SGX_EACCEPT = 0x05,
189	__SGX_EMODPE = 0x06,
190	__SGX_EACCEPTCOPY = 0x07
191	};
192	enum __enclu_type __T = (enum __enclu_type) __L;
193	unsigned int __R = 0;
194	if (!__builtin_constant_p (__T))
195	__enclu_generic (__L, __D[0], __D[1], __D[2], __R);
196	else switch (__T)
197	{
198	case __SGX_EREPORT:
199	case __SGX_EACCEPTCOPY:
200	__enclu_bcd (__L, __D[0], __D[1], __D[2], __R);
201	break;
202	case __SGX_EGETKEY:
203	case __SGX_ERESUME:
204	case __SGX_EACCEPT:
205	case __SGX_EMODPE:
206	__enclu_bc (__L, __D[0], __D[1], __R);
207	break;
208	case __SGX_EENTER:
209	__enclu_eenter (__L, __D[0], __D[1], __R);
210	break;
211	case __SGX_EEXIT:
212	__enclu_eexit (__L, __D[0], __D[1], __R);
213	break;
214	default:
215	__enclu_generic (__L, __D[0], __D[1], __D[2], __R);
216	}
217	return __R;
218	}
219
220	extern __inline unsigned int
221	__attribute__((__gnu_inline__, __always_inline__, __artificial__))
222	_enclv_u32 (const unsigned int __L, size_t __D[])
223	{
224	enum __enclv_type
225	{
226	__SGX_EDECVIRTCHILD = 0x00,
227	__SGX_EINCVIRTCHILD = 0x01,
228	__SGX_ESETCONTEXT = 0x02
229	};
230	unsigned int __R = 0;
231	if (!__builtin_constant_p (__L))
232	__enclv_generic (__L, __D[0], __D[1], __D[2], __R);
233	else switch (__L)
234	{
235	case __SGX_EDECVIRTCHILD:
236	case __SGX_EINCVIRTCHILD:
237	__enclv_bc (__L, __D[0], __D[1], __R);
238	break;
239	case __SGX_ESETCONTEXT:
240	__enclv_cd (__L, __D[1], __D[2], __R);
241	break;
242	default:
243	__enclv_generic (__L, __D[0], __D[1], __D[2], __R);
244	}
245	return __R;
246	}
247
248	#ifdef __DISABLE_SGX__
249	#undef __DISABLE_SGX__
250	#pragma GCC pop_options
251	#endif /* __DISABLE_SGX__ */
252
253	#endif /* _SGXINTRIN_H_INCLUDED */