visus
/
toolchain-gcc-arm-embedded
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
Tree: 898a39b5ab
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '898a39b5ab'
${ noResults }
toolchain-gcc-arm-embedded/share/doc/gcc-arm-none-eabi/html/gcc/PowerPC-AltiVec-Built_002di...

773 lines
40KB
Raw Blame History 

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

  2. <html>

  3. <!-- Copyright (C) 1988-2020 Free Software Foundation, Inc.

  4. 

  5. Permission is granted to copy, distribute and/or modify this document

  6. under the terms of the GNU Free Documentation License, Version 1.3 or

  7. any later version published by the Free Software Foundation; with the

  8. Invariant Sections being "Funding Free Software", the Front-Cover

  9. Texts being (a) (see below), and with the Back-Cover Texts being (b)

  10. (see below).  A copy of the license is included in the section entitled

  11. "GNU Free Documentation License".

  12. 

  13. (a) The FSF's Front-Cover Text is:

  14. 

  15. A GNU Manual

  16. 

  17. (b) The FSF's Back-Cover Text is:

  18. 

  19. You have freedom to copy and modify this GNU Manual, like GNU

  20.      software.  Copies published by the Free Software Foundation raise

  21.      funds for GNU development. -->

  22. <!-- Created by GNU Texinfo 6.5, http://www.gnu.org/software/texinfo/ -->

  23. <head>

  24. <meta http-equiv="Content-Type" content="text/html; charset=utf-8">

  25. <title>PowerPC AltiVec Built-in Functions Available on ISA 3.0 (Using the GNU Compiler Collection (GCC))</title>

  26. 

  27. <meta name="description" content="PowerPC AltiVec Built-in Functions Available on ISA 3.0 (Using the GNU Compiler Collection (GCC))">

  28. <meta name="keywords" content="PowerPC AltiVec Built-in Functions Available on ISA 3.0 (Using the GNU Compiler Collection (GCC))">

  29. <meta name="resource-type" content="document">

  30. <meta name="distribution" content="global">

  31. <meta name="Generator" content="makeinfo">

  32. <link href="index.html#Top" rel="start" title="Top">

  33. <link href="Option-Index.html#Option-Index" rel="index" title="Option Index">

  34. <link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">

  35. <link href="PowerPC-AltiVec_002fVSX-Built_002din-Functions.html#PowerPC-AltiVec_002fVSX-Built_002din-Functions" rel="up" title="PowerPC AltiVec/VSX Built-in Functions">

  36. <link href="PowerPC-Hardware-Transactional-Memory-Built_002din-Functions.html#PowerPC-Hardware-Transactional-Memory-Built_002din-Functions" rel="next" title="PowerPC Hardware Transactional Memory Built-in Functions">

  37. <link href="PowerPC-AltiVec-Built_002din-Functions-Available-on-ISA-2_002e07.html#PowerPC-AltiVec-Built_002din-Functions-Available-on-ISA-2_002e07" rel="prev" title="PowerPC AltiVec Built-in Functions Available on ISA 2.07">

  38. <style type="text/css">

  39. <!--

  40. a.summary-letter {text-decoration: none}

  41. blockquote.indentedblock {margin-right: 0em}

  42. blockquote.smallindentedblock {margin-right: 0em; font-size: smaller}

  43. blockquote.smallquotation {font-size: smaller}

  44. div.display {margin-left: 3.2em}

  45. div.example {margin-left: 3.2em}

  46. div.lisp {margin-left: 3.2em}

  47. div.smalldisplay {margin-left: 3.2em}

  48. div.smallexample {margin-left: 3.2em}

  49. div.smalllisp {margin-left: 3.2em}

  50. kbd {font-style: oblique}

  51. pre.display {font-family: inherit}

  52. pre.format {font-family: inherit}

  53. pre.menu-comment {font-family: serif}

  54. pre.menu-preformatted {font-family: serif}

  55. pre.smalldisplay {font-family: inherit; font-size: smaller}

  56. pre.smallexample {font-size: smaller}

  57. pre.smallformat {font-family: inherit; font-size: smaller}

  58. pre.smalllisp {font-size: smaller}

  59. span.nolinebreak {white-space: nowrap}

  60. span.roman {font-family: initial; font-weight: normal}

  61. span.sansserif {font-family: sans-serif; font-weight: normal}

  62. ul.no-bullet {list-style: none}

  63. -->

  64. </style>

  65. 

  66. 

  67. </head>

  68. 

  69. <body lang="en">

  70. <a name="PowerPC-AltiVec-Built_002din-Functions-Available-on-ISA-3_002e0"></a>

  71. <div class="header">

  72. <p>

  73. Previous: <a href="PowerPC-AltiVec-Built_002din-Functions-Available-on-ISA-2_002e07.html#PowerPC-AltiVec-Built_002din-Functions-Available-on-ISA-2_002e07" accesskey="p" rel="prev">PowerPC AltiVec Built-in Functions Available on ISA 2.07</a>, Up: <a href="PowerPC-AltiVec_002fVSX-Built_002din-Functions.html#PowerPC-AltiVec_002fVSX-Built_002din-Functions" accesskey="u" rel="up">PowerPC AltiVec/VSX Built-in Functions</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Option-Index.html#Option-Index" title="Index" rel="index">Index</a>]</p>

  74. </div>

  75. <hr>

  76. <a name="PowerPC-AltiVec-Built_002din-Functions-Available-on-ISA-3_002e0-1"></a>

  77. <h4 class="subsubsection">6.60.23.4 PowerPC AltiVec Built-in Functions Available on ISA 3.0</h4>

  78. 

  79. <p>The following additional built-in functions are also available for the

  80. PowerPC family of processors, starting with ISA 3.0

  81. (<samp>-mcpu=power9</samp>) or later:

  82. </p><div class="smallexample">

  83. <pre class="smallexample">unsigned int scalar_extract_exp (double source);

  84. unsigned long long int scalar_extract_exp (__ieee128 source);

  85. 

  86. unsigned long long int scalar_extract_sig (double source);

  87. unsigned __int128 scalar_extract_sig (__ieee128 source);

  88. 

  89. double scalar_insert_exp (unsigned long long int significand,

  90.                           unsigned long long int exponent);

  91. double scalar_insert_exp (double significand, unsigned long long int exponent);

  92. 

  93. ieee_128 scalar_insert_exp (unsigned __int128 significand,

  94.                             unsigned long long int exponent);

  95. ieee_128 scalar_insert_exp (ieee_128 significand, unsigned long long int exponent);

  96. 

  97. int scalar_cmp_exp_gt (double arg1, double arg2);

  98. int scalar_cmp_exp_lt (double arg1, double arg2);

  99. int scalar_cmp_exp_eq (double arg1, double arg2);

  100. int scalar_cmp_exp_unordered (double arg1, double arg2);

  101. 

  102. bool scalar_test_data_class (float source, const int condition);

  103. bool scalar_test_data_class (double source, const int condition);

  104. bool scalar_test_data_class (__ieee128 source, const int condition);

  105. 

  106. bool scalar_test_neg (float source);

  107. bool scalar_test_neg (double source);

  108. bool scalar_test_neg (__ieee128 source);

  109. 

  110. vector _uint128_t vec_msum (vector unsigned long long,

  111. 			    vector unsigned long long,

  112. 			    vector _uint128_t);

  113. vector _int128_t vec_msum (vector signed long long,

  114. 			   vector signed long long,

  115. 			   vector _int128_t);

  116. </pre></div>

  117. 

  118. <p>The <code>scalar_extract_exp</code> and <code>scalar_extract_sig</code>

  119. functions require a 64-bit environment supporting ISA 3.0 or later.

  120. The <code>scalar_extract_exp</code> and <code>scalar_extract_sig</code> built-in

  121. functions return the significand and the biased exponent value

  122. respectively of their <code>source</code> arguments.

  123. When supplied with a 64-bit <code>source</code> argument, the

  124. result returned by <code>scalar_extract_sig</code> has

  125. the <code>0x0010000000000000</code> bit set if the

  126. function&rsquo;s <code>source</code> argument is in normalized form.

  127. Otherwise, this bit is set to 0.

  128. When supplied with a 128-bit <code>source</code> argument, the

  129. <code>0x00010000000000000000000000000000</code> bit of the result is

  130. treated similarly.

  131. Note that the sign of the significand is not represented in the result

  132. returned from the <code>scalar_extract_sig</code> function.  Use the

  133. <code>scalar_test_neg</code> function to test the sign of its <code>double</code>

  134. argument.

  135. The <code>vec_msum</code> functions perform a vector multiply-sum, returning

  136. the result of arg1*arg2+arg3.  ISA 3.0 adds support for vec_msum returning

  137. a vector int128 result.

  138. </p>

  139. <p>The <code>scalar_insert_exp</code>

  140. functions require a 64-bit environment supporting ISA 3.0 or later.

  141. When supplied with a 64-bit first argument, the

  142. <code>scalar_insert_exp</code> built-in function returns a double-precision

  143. floating point value that is constructed by assembling the values of its

  144. <code>significand</code> and <code>exponent</code> arguments.  The sign of the

  145. result is copied from the most significant bit of the

  146. <code>significand</code> argument.  The significand and exponent components

  147. of the result are composed of the least significant 11 bits of the

  148. <code>exponent</code> argument and the least significant 52 bits of the

  149. <code>significand</code> argument respectively.

  150. </p>

  151. <p>When supplied with a 128-bit first argument, the

  152. <code>scalar_insert_exp</code> built-in function returns a quad-precision

  153. ieee floating point value.  The sign bit of the result is copied from

  154. the most significant bit of the <code>significand</code> argument.

  155. The significand and exponent components of the result are composed of

  156. the least significant 15 bits of the <code>exponent</code> argument and the

  157. least significant 112 bits of the <code>significand</code> argument respectively.

  158. </p>

  159. <p>The <code>scalar_cmp_exp_gt</code>, <code>scalar_cmp_exp_lt</code>,

  160. <code>scalar_cmp_exp_eq</code>, and <code>scalar_cmp_exp_unordered</code> built-in

  161. functions return a non-zero value if <code>arg1</code> is greater than, less

  162. than, equal to, or not comparable to <code>arg2</code> respectively.  The

  163. arguments are not comparable if one or the other equals NaN (not a

  164. number). 

  165. </p>

  166. <p>The <code>scalar_test_data_class</code> built-in function returns 1

  167. if any of the condition tests enabled by the value of the

  168. <code>condition</code> variable are true, and 0 otherwise.  The

  169. <code>condition</code> argument must be a compile-time constant integer with

  170. value not exceeding 127.  The

  171. <code>condition</code> argument is encoded as a bitmask with each bit

  172. enabling the testing of a different condition, as characterized by the

  173. following:

  174. </p><div class="smallexample">

  175. <pre class="smallexample">0x40    Test for NaN

  176. 0x20    Test for +Infinity

  177. 0x10    Test for -Infinity

  178. 0x08    Test for +Zero

  179. 0x04    Test for -Zero

  180. 0x02    Test for +Denormal

  181. 0x01    Test for -Denormal

  182. </pre></div>

  183. 

  184. <p>The <code>scalar_test_neg</code> built-in function returns 1 if its

  185. <code>source</code> argument holds a negative value, 0 otherwise.

  186. </p>

  187. <p>The following built-in functions are also available for the PowerPC family

  188. of processors, starting with ISA 3.0 or later

  189. (<samp>-mcpu=power9</samp>).  These string functions are described

  190. separately in order to group the descriptions closer to the function

  191. prototypes:

  192. </p><div class="smallexample">

  193. <pre class="smallexample">int vec_all_nez (vector signed char, vector signed char);

  194. int vec_all_nez (vector unsigned char, vector unsigned char);

  195. int vec_all_nez (vector signed short, vector signed short);

  196. int vec_all_nez (vector unsigned short, vector unsigned short);

  197. int vec_all_nez (vector signed int, vector signed int);

  198. int vec_all_nez (vector unsigned int, vector unsigned int);

  199. 

  200. int vec_any_eqz (vector signed char, vector signed char);

  201. int vec_any_eqz (vector unsigned char, vector unsigned char);

  202. int vec_any_eqz (vector signed short, vector signed short);

  203. int vec_any_eqz (vector unsigned short, vector unsigned short);

  204. int vec_any_eqz (vector signed int, vector signed int);

  205. int vec_any_eqz (vector unsigned int, vector unsigned int);

  206. 

  207. vector bool char vec_cmpnez (vector signed char arg1, vector signed char arg2);

  208. vector bool char vec_cmpnez (vector unsigned char arg1, vector unsigned char arg2);

  209. vector bool short vec_cmpnez (vector signed short arg1, vector signed short arg2);

  210. vector bool short vec_cmpnez (vector unsigned short arg1, vector unsigned short arg2);

  211. vector bool int vec_cmpnez (vector signed int arg1, vector signed int arg2);

  212. vector bool int vec_cmpnez (vector unsigned int, vector unsigned int);

  213. 

  214. vector signed char vec_cnttz (vector signed char);

  215. vector unsigned char vec_cnttz (vector unsigned char);

  216. vector signed short vec_cnttz (vector signed short);

  217. vector unsigned short vec_cnttz (vector unsigned short);

  218. vector signed int vec_cnttz (vector signed int);

  219. vector unsigned int vec_cnttz (vector unsigned int);

  220. vector signed long long vec_cnttz (vector signed long long);

  221. vector unsigned long long vec_cnttz (vector unsigned long long);

  222. 

  223. signed int vec_cntlz_lsbb (vector signed char);

  224. signed int vec_cntlz_lsbb (vector unsigned char);

  225. 

  226. signed int vec_cnttz_lsbb (vector signed char);

  227. signed int vec_cnttz_lsbb (vector unsigned char);

  228. 

  229. unsigned int vec_first_match_index (vector signed char, vector signed char);

  230. unsigned int vec_first_match_index (vector unsigned char, vector unsigned char);

  231. unsigned int vec_first_match_index (vector signed int, vector signed int);

  232. unsigned int vec_first_match_index (vector unsigned int, vector unsigned int);

  233. unsigned int vec_first_match_index (vector signed short, vector signed short);

  234. unsigned int vec_first_match_index (vector unsigned short, vector unsigned short);

  235. unsigned int vec_first_match_or_eos_index (vector signed char, vector signed char);

  236. unsigned int vec_first_match_or_eos_index (vector unsigned char, vector unsigned char);

  237. unsigned int vec_first_match_or_eos_index (vector signed int, vector signed int);

  238. unsigned int vec_first_match_or_eos_index (vector unsigned int, vector unsigned int);

  239. unsigned int vec_first_match_or_eos_index (vector signed short, vector signed short);

  240. unsigned int vec_first_match_or_eos_index (vector unsigned short,

  241.                                            vector unsigned short);

  242. unsigned int vec_first_mismatch_index (vector signed char, vector signed char);

  243. unsigned int vec_first_mismatch_index (vector unsigned char, vector unsigned char);

  244. unsigned int vec_first_mismatch_index (vector signed int, vector signed int);

  245. unsigned int vec_first_mismatch_index (vector unsigned int, vector unsigned int);

  246. unsigned int vec_first_mismatch_index (vector signed short, vector signed short);

  247. unsigned int vec_first_mismatch_index (vector unsigned short, vector unsigned short);

  248. unsigned int vec_first_mismatch_or_eos_index (vector signed char, vector signed char);

  249. unsigned int vec_first_mismatch_or_eos_index (vector unsigned char,

  250.                                               vector unsigned char);

  251. unsigned int vec_first_mismatch_or_eos_index (vector signed int, vector signed int);

  252. unsigned int vec_first_mismatch_or_eos_index (vector unsigned int, vector unsigned int);

  253. unsigned int vec_first_mismatch_or_eos_index (vector signed short, vector signed short);

  254. unsigned int vec_first_mismatch_or_eos_index (vector unsigned short,

  255.                                               vector unsigned short);

  256. 

  257. vector unsigned short vec_pack_to_short_fp32 (vector float, vector float);

  258. 

  259. vector signed char vec_xl_be (signed long long, signed char *);

  260. vector unsigned char vec_xl_be (signed long long, unsigned char *);

  261. vector signed int vec_xl_be (signed long long, signed int *);

  262. vector unsigned int vec_xl_be (signed long long, unsigned int *);

  263. vector signed __int128 vec_xl_be (signed long long, signed __int128 *);

  264. vector unsigned __int128 vec_xl_be (signed long long, unsigned __int128 *);

  265. vector signed long long vec_xl_be (signed long long, signed long long *);

  266. vector unsigned long long vec_xl_be (signed long long, unsigned long long *);

  267. vector signed short vec_xl_be (signed long long, signed short *);

  268. vector unsigned short vec_xl_be (signed long long, unsigned short *);

  269. vector double vec_xl_be (signed long long, double *);

  270. vector float vec_xl_be (signed long long, float *);

  271. 

  272. vector signed char vec_xl_len (signed char *addr, size_t len);

  273. vector unsigned char vec_xl_len (unsigned char *addr, size_t len);

  274. vector signed int vec_xl_len (signed int *addr, size_t len);

  275. vector unsigned int vec_xl_len (unsigned int *addr, size_t len);

  276. vector signed __int128 vec_xl_len (signed __int128 *addr, size_t len);

  277. vector unsigned __int128 vec_xl_len (unsigned __int128 *addr, size_t len);

  278. vector signed long long vec_xl_len (signed long long *addr, size_t len);

  279. vector unsigned long long vec_xl_len (unsigned long long *addr, size_t len);

  280. vector signed short vec_xl_len (signed short *addr, size_t len);

  281. vector unsigned short vec_xl_len (unsigned short *addr, size_t len);

  282. vector double vec_xl_len (double *addr, size_t len);

  283. vector float vec_xl_len (float *addr, size_t len);

  284. 

  285. vector unsigned char vec_xl_len_r (unsigned char *addr, size_t len);

  286. 

  287. void vec_xst_len (vector signed char data, signed char *addr, size_t len);

  288. void vec_xst_len (vector unsigned char data, unsigned char *addr, size_t len);

  289. void vec_xst_len (vector signed int data, signed int *addr, size_t len);

  290. void vec_xst_len (vector unsigned int data, unsigned int *addr, size_t len);

  291. void vec_xst_len (vector unsigned __int128 data, unsigned __int128 *addr, size_t len);

  292. void vec_xst_len (vector signed long long data, signed long long *addr, size_t len);

  293. void vec_xst_len (vector unsigned long long data, unsigned long long *addr, size_t len);

  294. void vec_xst_len (vector signed short data, signed short *addr, size_t len);

  295. void vec_xst_len (vector unsigned short data, unsigned short *addr, size_t len);

  296. void vec_xst_len (vector signed __int128 data, signed __int128 *addr, size_t len);

  297. void vec_xst_len (vector double data, double *addr, size_t len);

  298. void vec_xst_len (vector float data, float *addr, size_t len);

  299. 

  300. void vec_xst_len_r (vector unsigned char data, unsigned char *addr, size_t len);

  301. 

  302. signed char vec_xlx (unsigned int index, vector signed char data);

  303. unsigned char vec_xlx (unsigned int index, vector unsigned char data);

  304. signed short vec_xlx (unsigned int index, vector signed short data);

  305. unsigned short vec_xlx (unsigned int index, vector unsigned short data);

  306. signed int vec_xlx (unsigned int index, vector signed int data);

  307. unsigned int vec_xlx (unsigned int index, vector unsigned int data);

  308. float vec_xlx (unsigned int index, vector float data);

  309. 

  310. signed char vec_xrx (unsigned int index, vector signed char data);

  311. unsigned char vec_xrx (unsigned int index, vector unsigned char data);

  312. signed short vec_xrx (unsigned int index, vector signed short data);

  313. unsigned short vec_xrx (unsigned int index, vector unsigned short data);

  314. signed int vec_xrx (unsigned int index, vector signed int data);

  315. unsigned int vec_xrx (unsigned int index, vector unsigned int data);

  316. float vec_xrx (unsigned int index, vector float data);

  317. </pre></div>

  318. 

  319. <p>The <code>vec_all_nez</code>, <code>vec_any_eqz</code>, and <code>vec_cmpnez</code>

  320. perform pairwise comparisons between the elements at the same

  321. positions within their two vector arguments.

  322. The <code>vec_all_nez</code> function returns a

  323. non-zero value if and only if all pairwise comparisons are not

  324. equal and no element of either vector argument contains a zero.

  325. The <code>vec_any_eqz</code> function returns a

  326. non-zero value if and only if at least one pairwise comparison is equal

  327. or if at least one element of either vector argument contains a zero.

  328. The <code>vec_cmpnez</code> function returns a vector of the same type as

  329. its two arguments, within which each element consists of all ones to

  330. denote that either the corresponding elements of the incoming arguments are

  331. not equal or that at least one of the corresponding elements contains

  332. zero.  Otherwise, the element of the returned vector contains all zeros.

  333. </p>

  334. <p>The <code>vec_cntlz_lsbb</code> function returns the count of the number of

  335. consecutive leading byte elements (starting from position 0 within the

  336. supplied vector argument) for which the least-significant bit

  337. equals zero.  The <code>vec_cnttz_lsbb</code> function returns the count of

  338. the number of consecutive trailing byte elements (starting from

  339. position 15 and counting backwards within the supplied vector

  340. argument) for which the least-significant bit equals zero.

  341. </p>

  342. <p>The <code>vec_xl_len</code> and <code>vec_xst_len</code> functions require a

  343. 64-bit environment supporting ISA 3.0 or later.  The <code>vec_xl_len</code>

  344. function loads a variable length vector from memory.  The

  345. <code>vec_xst_len</code> function stores a variable length vector to memory.

  346. With both the <code>vec_xl_len</code> and <code>vec_xst_len</code> functions, the

  347. <code>addr</code> argument represents the memory address to or from which

  348. data will be transferred, and the

  349. <code>len</code> argument represents the number of bytes to be

  350. transferred, as computed by the C expression <code>min((len &amp; 0xff), 16)</code>.

  351. If this expression&rsquo;s value is not a multiple of the vector element&rsquo;s

  352. size, the behavior of this function is undefined.

  353. In the case that the underlying computer is configured to run in

  354. big-endian mode, the data transfer moves bytes 0 to <code>(len - 1)</code> of

  355. the corresponding vector.  In little-endian mode, the data transfer

  356. moves bytes <code>(16 - len)</code> to <code>15</code> of the corresponding

  357. vector.  For the load function, any bytes of the result vector that

  358. are not loaded from memory are set to zero.

  359. The value of the <code>addr</code> argument need not be aligned on a

  360. multiple of the vector&rsquo;s element size.

  361. </p>

  362. <p>The <code>vec_xlx</code> and <code>vec_xrx</code> functions extract the single

  363. element selected by the <code>index</code> argument from the vector

  364. represented by the <code>data</code> argument.  The <code>index</code> argument

  365. always specifies a byte offset, regardless of the size of the vector

  366. element.  With <code>vec_xlx</code>, <code>index</code> is the offset of the first

  367. byte of the element to be extracted.  With <code>vec_xrx</code>, <code>index</code>

  368. represents the last byte of the element to be extracted, measured

  369. from the right end of the vector.  In other words, the last byte of

  370. the element to be extracted is found at position <code>(15 - index)</code>.

  371. There is no requirement that <code>index</code> be a multiple of the vector

  372. element size.  However, if the size of the vector element added to

  373. <code>index</code> is greater than 15, the content of the returned value is

  374. undefined.

  375. </p>

  376. <p>If the ISA 3.0 instruction set additions (<samp>-mcpu=power9</samp>)

  377. are available:

  378. </p>

  379. <div class="smallexample">

  380. <pre class="smallexample">vector unsigned long long vec_bperm (vector unsigned long long, vector unsigned char);

  381. 

  382. vector bool char vec_cmpne (vector bool char, vector bool char);

  383. vector bool char vec_cmpne (vector signed char, vector signed char);

  384. vector bool char vec_cmpne (vector unsigned char, vector unsigned char);

  385. vector bool int vec_cmpne (vector bool int, vector bool int);

  386. vector bool int vec_cmpne (vector signed int, vector signed int);

  387. vector bool int vec_cmpne (vector unsigned int, vector unsigned int);

  388. vector bool long long vec_cmpne (vector bool long long, vector bool long long);

  389. vector bool long long vec_cmpne (vector signed long long, vector signed long long);

  390. vector bool long long vec_cmpne (vector unsigned long long, vector unsigned long long);

  391. vector bool short vec_cmpne (vector bool short, vector bool short);

  392. vector bool short vec_cmpne (vector signed short, vector signed short);

  393. vector bool short vec_cmpne (vector unsigned short, vector unsigned short);

  394. vector bool long long vec_cmpne (vector double, vector double);

  395. vector bool int vec_cmpne (vector float, vector float);

  396. 

  397. vector float vec_extract_fp32_from_shorth (vector unsigned short);

  398. vector float vec_extract_fp32_from_shortl (vector unsigned short);

  399. 

  400. vector long long vec_vctz (vector long long);

  401. vector unsigned long long vec_vctz (vector unsigned long long);

  402. vector int vec_vctz (vector int);

  403. vector unsigned int vec_vctz (vector int);

  404. vector short vec_vctz (vector short);

  405. vector unsigned short vec_vctz (vector unsigned short);

  406. vector signed char vec_vctz (vector signed char);

  407. vector unsigned char vec_vctz (vector unsigned char);

  408. 

  409. vector signed char vec_vctzb (vector signed char);

  410. vector unsigned char vec_vctzb (vector unsigned char);

  411. 

  412. vector long long vec_vctzd (vector long long);

  413. vector unsigned long long vec_vctzd (vector unsigned long long);

  414. 

  415. vector short vec_vctzh (vector short);

  416. vector unsigned short vec_vctzh (vector unsigned short);

  417. 

  418. vector int vec_vctzw (vector int);

  419. vector unsigned int vec_vctzw (vector int);

  420. 

  421. vector unsigned long long vec_extract4b (vector unsigned char, const int);

  422. 

  423. vector unsigned char vec_insert4b (vector signed int, vector unsigned char,

  424.                                    const int);

  425. vector unsigned char vec_insert4b (vector unsigned int, vector unsigned char,

  426.                                    const int);

  427. 

  428. vector unsigned int vec_parity_lsbb (vector signed int);

  429. vector unsigned int vec_parity_lsbb (vector unsigned int);

  430. vector unsigned __int128 vec_parity_lsbb (vector signed __int128);

  431. vector unsigned __int128 vec_parity_lsbb (vector unsigned __int128);

  432. vector unsigned long long vec_parity_lsbb (vector signed long long);

  433. vector unsigned long long vec_parity_lsbb (vector unsigned long long);

  434. 

  435. vector int vec_vprtyb (vector int);

  436. vector unsigned int vec_vprtyb (vector unsigned int);

  437. vector long long vec_vprtyb (vector long long);

  438. vector unsigned long long vec_vprtyb (vector unsigned long long);

  439. 

  440. vector int vec_vprtybw (vector int);

  441. vector unsigned int vec_vprtybw (vector unsigned int);

  442. 

  443. vector long long vec_vprtybd (vector long long);

  444. vector unsigned long long vec_vprtybd (vector unsigned long long);

  445. </pre></div>

  446. 

  447. <p>On 64-bit targets, if the ISA 3.0 additions (<samp>-mcpu=power9</samp>)

  448. are available:

  449. </p>

  450. <div class="smallexample">

  451. <pre class="smallexample">vector long vec_vprtyb (vector long);

  452. vector unsigned long vec_vprtyb (vector unsigned long);

  453. vector __int128 vec_vprtyb (vector __int128);

  454. vector __uint128 vec_vprtyb (vector __uint128);

  455. 

  456. vector long vec_vprtybd (vector long);

  457. vector unsigned long vec_vprtybd (vector unsigned long);

  458. 

  459. vector __int128 vec_vprtybq (vector __int128);

  460. vector __uint128 vec_vprtybd (vector __uint128);

  461. </pre></div>

  462. 

  463. <p>The following built-in vector functions are available for the PowerPC family

  464. of processors, starting with ISA 3.0 or later (<samp>-mcpu=power9</samp>):

  465. </p><div class="smallexample">

  466. <pre class="smallexample">__vector unsigned char

  467. vec_slv (__vector unsigned char src, __vector unsigned char shift_distance);

  468. __vector unsigned char

  469. vec_srv (__vector unsigned char src, __vector unsigned char shift_distance);

  470. </pre></div>

  471. 

  472. <p>The <code>vec_slv</code> and <code>vec_srv</code> functions operate on

  473. all of the bytes of their <code>src</code> and <code>shift_distance</code>

  474. arguments in parallel.  The behavior of the <code>vec_slv</code> is as if

  475. there existed a temporary array of 17 unsigned characters

  476. <code>slv_array</code> within which elements 0 through 15 are the same as

  477. the entries in the <code>src</code> array and element 16 equals 0.  The

  478. result returned from the <code>vec_slv</code> function is a

  479. <code>__vector</code> of 16 unsigned characters within which element

  480. <code>i</code> is computed using the C expression

  481. <code>0xff &amp; (*((unsigned short *)(slv_array + i)) &lt;&lt; (0x07 &amp;

  482. shift_distance[i]))</code>,

  483. with this resulting value coerced to the <code>unsigned char</code> type.

  484. The behavior of the <code>vec_srv</code> is as if

  485. there existed a temporary array of 17 unsigned characters

  486. <code>srv_array</code> within which element 0 equals zero and

  487. elements 1 through 16 equal the elements 0 through 15 of

  488. the <code>src</code> array.  The

  489. result returned from the <code>vec_srv</code> function is a

  490. <code>__vector</code> of 16 unsigned characters within which element

  491. <code>i</code> is computed using the C expression

  492. <code>0xff &amp; (*((unsigned short *)(srv_array + i)) &gt;&gt;

  493. (0x07 &amp; shift_distance[i]))</code>,

  494. with this resulting value coerced to the <code>unsigned char</code> type.

  495. </p>

  496. <p>The following built-in functions are available for the PowerPC family

  497. of processors, starting with ISA 3.0 or later (<samp>-mcpu=power9</samp>):

  498. </p><div class="smallexample">

  499. <pre class="smallexample">__vector unsigned char

  500. vec_absd (__vector unsigned char arg1, __vector unsigned char arg2);

  501. __vector unsigned short

  502. vec_absd (__vector unsigned short arg1, __vector unsigned short arg2);

  503. __vector unsigned int

  504. vec_absd (__vector unsigned int arg1, __vector unsigned int arg2);

  505. 

  506. __vector unsigned char

  507. vec_absdb (__vector unsigned char arg1, __vector unsigned char arg2);

  508. __vector unsigned short

  509. vec_absdh (__vector unsigned short arg1, __vector unsigned short arg2);

  510. __vector unsigned int

  511. vec_absdw (__vector unsigned int arg1, __vector unsigned int arg2);

  512. </pre></div>

  513. 

  514. <p>The <code>vec_absd</code>, <code>vec_absdb</code>, <code>vec_absdh</code>, and

  515. <code>vec_absdw</code> built-in functions each computes the absolute

  516. differences of the pairs of vector elements supplied in its two vector

  517. arguments, placing the absolute differences into the corresponding

  518. elements of the vector result.

  519. </p>

  520. <p>The following built-in functions are available for the PowerPC family

  521. of processors, starting with ISA 3.0 or later (<samp>-mcpu=power9</samp>):

  522. </p><div class="smallexample">

  523. <pre class="smallexample">__vector unsigned int vec_extract_exp (__vector float source);

  524. __vector unsigned long long int vec_extract_exp (__vector double source);

  525. 

  526. __vector unsigned int vec_extract_sig (__vector float source);

  527. __vector unsigned long long int vec_extract_sig (__vector double source);

  528. 

  529. __vector float vec_insert_exp (__vector unsigned int significands,

  530.                                __vector unsigned int exponents);

  531. __vector float vec_insert_exp (__vector unsigned float significands,

  532.                                __vector unsigned int exponents);

  533. __vector double vec_insert_exp (__vector unsigned long long int significands,

  534.                                 __vector unsigned long long int exponents);

  535. __vector double vec_insert_exp (__vector unsigned double significands,

  536.                                 __vector unsigned long long int exponents);

  537. 

  538. __vector bool int vec_test_data_class (__vector float source, const int condition);

  539. __vector bool long long int vec_test_data_class (__vector double source,

  540.                                                  const int condition);

  541. </pre></div>

  542. 

  543. <p>The <code>vec_extract_sig</code> and <code>vec_extract_exp</code> built-in

  544. functions return vectors representing the significands and biased

  545. exponent values of their <code>source</code> arguments respectively.

  546. Within the result vector returned by <code>vec_extract_sig</code>, the

  547. <code>0x800000</code> bit of each vector element returned when the

  548. function&rsquo;s <code>source</code> argument is of type <code>float</code> is set to 1

  549. if the corresponding floating point value is in normalized form.

  550. Otherwise, this bit is set to 0.  When the <code>source</code> argument is

  551. of type <code>double</code>, the <code>0x10000000000000</code> bit within each of

  552. the result vector&rsquo;s elements is set according to the same rules.

  553. Note that the sign of the significand is not represented in the result

  554. returned from the <code>vec_extract_sig</code> function.  To extract the

  555. sign bits, use the

  556. <code>vec_cpsgn</code> function, which returns a new vector within which all

  557. of the sign bits of its second argument vector are overwritten with the

  558. sign bits copied from the coresponding elements of its first argument

  559. vector, and all other (non-sign) bits of the second argument vector

  560. are copied unchanged into the result vector.

  561. </p>

  562. <p>The <code>vec_insert_exp</code> built-in functions return a vector of

  563. single- or double-precision floating

  564. point values constructed by assembling the values of their

  565. <code>significands</code> and <code>exponents</code> arguments into the

  566. corresponding elements of the returned vector.

  567. The sign of each

  568. element of the result is copied from the most significant bit of the

  569. corresponding entry within the <code>significands</code> argument.

  570. Note that the relevant

  571. bits of the <code>significands</code> argument are the same, for both integer

  572. and floating point types.

  573. The

  574. significand and exponent components of each element of the result are

  575. composed of the least significant bits of the corresponding

  576. <code>significands</code> element and the least significant bits of the

  577. corresponding <code>exponents</code> element.

  578. </p>

  579. <p>The <code>vec_test_data_class</code> built-in function returns a vector

  580. representing the results of testing the <code>source</code> vector for the

  581. condition selected by the <code>condition</code> argument.  The

  582. <code>condition</code> argument must be a compile-time constant integer with

  583. value not exceeding 127.  The

  584. <code>condition</code> argument is encoded as a bitmask with each bit

  585. enabling the testing of a different condition, as characterized by the

  586. following:

  587. </p><div class="smallexample">

  588. <pre class="smallexample">0x40    Test for NaN

  589. 0x20    Test for +Infinity

  590. 0x10    Test for -Infinity

  591. 0x08    Test for +Zero

  592. 0x04    Test for -Zero

  593. 0x02    Test for +Denormal

  594. 0x01    Test for -Denormal

  595. </pre></div>

  596. 

  597. <p>If any of the enabled test conditions is true, the corresponding entry

  598. in the result vector is -1.  Otherwise (all of the enabled test

  599. conditions are false), the corresponding entry of the result vector is 0.

  600. </p>

  601. <p>The following built-in functions are available for the PowerPC family

  602. of processors, starting with ISA 3.0 or later (<samp>-mcpu=power9</samp>):

  603. </p><div class="smallexample">

  604. <pre class="smallexample">vector unsigned int vec_rlmi (vector unsigned int, vector unsigned int,

  605.                               vector unsigned int);

  606. vector unsigned long long vec_rlmi (vector unsigned long long,

  607.                                     vector unsigned long long,

  608.                                     vector unsigned long long);

  609. vector unsigned int vec_rlnm (vector unsigned int, vector unsigned int,

  610.                               vector unsigned int);

  611. vector unsigned long long vec_rlnm (vector unsigned long long,

  612.                                     vector unsigned long long,

  613.                                     vector unsigned long long);

  614. vector unsigned int vec_vrlnm (vector unsigned int, vector unsigned int);

  615. vector unsigned long long vec_vrlnm (vector unsigned long long,

  616.                                      vector unsigned long long);

  617. </pre></div>

  618. 

  619. <p>The result of <code>vec_rlmi</code> is obtained by rotating each element of

  620. the first argument vector left and inserting it under mask into the

  621. second argument vector.  The third argument vector contains the mask

  622. beginning in bits 11:15, the mask end in bits 19:23, and the shift

  623. count in bits 27:31, of each element.

  624. </p>

  625. <p>The result of <code>vec_rlnm</code> is obtained by rotating each element of

  626. the first argument vector left and ANDing it with a mask specified by

  627. the second and third argument vectors.  The second argument vector

  628. contains the shift count for each element in the low-order byte.  The

  629. third argument vector contains the mask end for each element in the

  630. low-order byte, with the mask begin in the next higher byte.

  631. </p>

  632. <p>The result of <code>vec_vrlnm</code> is obtained by rotating each element

  633. of the first argument vector left and ANDing it with a mask.  The

  634. second argument vector contains the mask  beginning in bits 11:15,

  635. the mask end in bits 19:23, and the shift count in bits 27:31,

  636. of each element.

  637. </p>

  638. <p>If the ISA 3.0 instruction set additions (<samp>-mcpu=power9</samp>)

  639. are available:

  640. </p><div class="smallexample">

  641. <pre class="smallexample">vector signed bool char vec_revb (vector signed char);

  642. vector signed char vec_revb (vector signed char);

  643. vector unsigned char vec_revb (vector unsigned char);

  644. vector bool short vec_revb (vector bool short);

  645. vector short vec_revb (vector short);

  646. vector unsigned short vec_revb (vector unsigned short);

  647. vector bool int vec_revb (vector bool int);

  648. vector int vec_revb (vector int);

  649. vector unsigned int vec_revb (vector unsigned int);

  650. vector float vec_revb (vector float);

  651. vector bool long long vec_revb (vector bool long long);

  652. vector long long vec_revb (vector long long);

  653. vector unsigned long long vec_revb (vector unsigned long long);

  654. vector double vec_revb (vector double);

  655. </pre></div>

  656. 

  657. <p>On 64-bit targets, if the ISA 3.0 additions (<samp>-mcpu=power9</samp>)

  658. are available:

  659. </p><div class="smallexample">

  660. <pre class="smallexample">vector long vec_revb (vector long);

  661. vector unsigned long vec_revb (vector unsigned long);

  662. vector __int128 vec_revb (vector __int128);

  663. vector __uint128 vec_revb (vector __uint128);

  664. </pre></div>

  665. 

  666. <p>The <code>vec_revb</code> built-in function reverses the bytes on an element

  667. by element basis.  A vector of <code>vector unsigned char</code> or

  668. <code>vector signed char</code> reverses the bytes in the whole word.

  669. </p>

  670. <p>If the cryptographic instructions are enabled (<samp>-mcrypto</samp> or

  671. <samp>-mcpu=power8</samp>), the following builtins are enabled.

  672. </p>

  673. <div class="smallexample">

  674. <pre class="smallexample">vector unsigned long long __builtin_crypto_vsbox (vector unsigned long long);

  675. 

  676. vector unsigned char vec_sbox_be (vector unsigned char);

  677. 

  678. vector unsigned long long __builtin_crypto_vcipher (vector unsigned long long,

  679.                                                     vector unsigned long long);

  680. 

  681. vector unsigned char vec_cipher_be (vector unsigned char, vector unsigned char);

  682. 

  683. vector unsigned long long __builtin_crypto_vcipherlast

  684.                                      (vector unsigned long long,

  685.                                       vector unsigned long long);

  686. 

  687. vector unsigned char vec_cipherlast_be (vector unsigned char,

  688.                                         vector unsigned char);

  689. 

  690. vector unsigned long long __builtin_crypto_vncipher (vector unsigned long long,

  691.                                                      vector unsigned long long);

  692. 

  693. vector unsigned char vec_ncipher_be (vector unsigned char,

  694.                                      vector unsigned char);

  695. 

  696. vector unsigned long long __builtin_crypto_vncipherlast (vector unsigned long long,

  697.                                                          vector unsigned long long);

  698. 

  699. vector unsigned char vec_ncipherlast_be (vector unsigned char,

  700.                                          vector unsigned char);

  701. 

  702. vector unsigned char __builtin_crypto_vpermxor (vector unsigned char,

  703.                                                 vector unsigned char,

  704.                                                 vector unsigned char);

  705. 

  706. vector unsigned short __builtin_crypto_vpermxor (vector unsigned short,

  707.                                                  vector unsigned short,

  708.                                                  vector unsigned short);

  709. 

  710. vector unsigned int __builtin_crypto_vpermxor (vector unsigned int,

  711.                                                vector unsigned int,

  712.                                                vector unsigned int);

  713. 

  714. vector unsigned long long __builtin_crypto_vpermxor (vector unsigned long long,

  715.                                                      vector unsigned long long,

  716.                                                      vector unsigned long long);

  717. 

  718. vector unsigned char __builtin_crypto_vpmsumb (vector unsigned char,

  719.                                                vector unsigned char);

  720. 

  721. vector unsigned short __builtin_crypto_vpmsumh (vector unsigned short,

  722.                                                 vector unsigned short);

  723. 

  724. vector unsigned int __builtin_crypto_vpmsumw (vector unsigned int,

  725.                                               vector unsigned int);

  726. 

  727. vector unsigned long long __builtin_crypto_vpmsumd (vector unsigned long long,

  728.                                                     vector unsigned long long);

  729. 

  730. vector unsigned long long __builtin_crypto_vshasigmad (vector unsigned long long,

  731.                                                        int, int);

  732. 

  733. vector unsigned int __builtin_crypto_vshasigmaw (vector unsigned int, int, int);

  734. </pre></div>

  735. 

  736. <p>The second argument to <var>__builtin_crypto_vshasigmad</var> and

  737. <var>__builtin_crypto_vshasigmaw</var> must be a constant

  738. integer that is 0 or 1.  The third argument to these built-in functions

  739. must be a constant integer in the range of 0 to 15.

  740. </p>

  741. <p>If the ISA 3.0 instruction set additions 

  742. are enabled (<samp>-mcpu=power9</samp>), the following additional

  743. functions are available for both 32-bit and 64-bit targets.

  744. </p><div class="smallexample">

  745. <pre class="smallexample">vector short vec_xl (int, vector short *);

  746. vector short vec_xl (int, short *);

  747. vector unsigned short vec_xl (int, vector unsigned short *);

  748. vector unsigned short vec_xl (int, unsigned short *);

  749. vector char vec_xl (int, vector char *);

  750. vector char vec_xl (int, char *);

  751. vector unsigned char vec_xl (int, vector unsigned char *);

  752. vector unsigned char vec_xl (int, unsigned char *);

  753. 

  754. void vec_xst (vector short, int, vector short *);

  755. void vec_xst (vector short, int, short *);

  756. void vec_xst (vector unsigned short, int, vector unsigned short *);

  757. void vec_xst (vector unsigned short, int, unsigned short *);

  758. void vec_xst (vector char, int, vector char *);

  759. void vec_xst (vector char, int, char *);

  760. void vec_xst (vector unsigned char, int, vector unsigned char *);

  761. void vec_xst (vector unsigned char, int, unsigned char *);

  762. </pre></div>

  763. <hr>

  764. <div class="header">

  765. <p>

  766. Previous: <a href="PowerPC-AltiVec-Built_002din-Functions-Available-on-ISA-2_002e07.html#PowerPC-AltiVec-Built_002din-Functions-Available-on-ISA-2_002e07" accesskey="p" rel="prev">PowerPC AltiVec Built-in Functions Available on ISA 2.07</a>, Up: <a href="PowerPC-AltiVec_002fVSX-Built_002din-Functions.html#PowerPC-AltiVec_002fVSX-Built_002din-Functions" accesskey="u" rel="up">PowerPC AltiVec/VSX Built-in Functions</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Option-Index.html#Option-Index" title="Index" rel="index">Index</a>]</p>

  767. </div>

  768. 

  769. 

  770. 

  771. </body>

  772. </html>