Remove from docs too

Author: premanandrao

clang/include/clang/Basic/AttrDocs.td

@@ -4013,108 +4013,6 @@ with which a pipe interfaces. The id argument is the name of the I/O interface.
   }];
 }
 
-def SYCLIntelIVDepAttrDocs : Documentation {
-  let Category = DocCatVariable;
-  let Heading = "intel::ivdep";
-  let Content = [{
-This attribute applies to a loop. If no additional arguments are provided, it
-indicates that the backend may assume that the loop carries no dependences.
-If a safelen is provided then the backend may assume that all loop-carried
-dependences have a dependence distance of at least that length.
-If an array variable is provided then the backend may assume that there are
-no loop-carried dependences for this particular array within this loop.
-If both an array variable and a safelen are specified, the backend may assume
-that all loop-carried dependences for this particular array have a dependence
-distance of at least that length.
-Multiple ivdep attributes can be applied to the same loop, but only the greatest
-possible safelen will be chosen for each array, including the case where safelen
-is unspecified and is therefore considered infinite.
-In case of ivdep being applied both w/o an array variable and for a particular
-array, the array variables that were not designated a separate ivdep will receive
-the no-array ivdep's safelen, with the correspondent treatment by the backend.
-The ``[[intel::ivdep]]`` attribute applies a safelen value of 0 or 1 that has
-no effect on the loop and emits a suppressible warning when safelen value of 0
-or 1 is used.
-
-.. code-block:: c++
-
-  void foo() {
-    int a[10];
-    [[intel::ivdep]] for (int i = 0; i != 10; ++i) { }
-    [[intel::ivdep(2)]] for (int i = 0; i != 10; ++i) { }
-    [[intel::ivdep(a)]] for (int i = 0; i != 10; ++i) { }
-    [[intel::ivdep(a, 2)]] for (int i = 0; i != 10; ++i) { }
-  }
-
-  template<int N>
-  void bar() {
-    [[intel::ivdep(N)]] for(;;) { }
-  }
-
-  }];
-}
-
-def SYCLIntelInitiationIntervalAttrDocs : Documentation {
-  let Category = DocCatVariable;
-  let Heading = "intel::initiation_interval";
-  let Content = [{
-This attribute applies to a loop or a function. Indicates that the loop or
-function should be pipelined with an initiation interval of N. N must be a
-positive integer. Cannot be applied multiple times to the same loop or function.
-Cannot be used on the same loop or function in conjunction with
-disable_loop_pipelining.
-
-The ``[[intel::ii]]`` attribute spelling is a deprecated synonym for
-``[[intel::initiation_interval]]`` and will be removed in the future.
-
-.. code-block:: c++
-
-  void foo() {
-    int var = 0;
-    [[intel::initiation_interval(4)]] for (int i = 0; i < 10; ++i) var++;
-  }
-
-  [[intel::initiation_interval(4)]] void foo1 { }
-
-  template<int N>
-  void bar() {
-    [[intel::initiation_interval(N)]] for(;;) { }
-  }
-
-  template<int N>
-  [[intel::initiation_interval(N)]] void bar1 { }
-
-  }];
-}
-
-def SYCLIntelMaxConcurrencyAttrDocs : Documentation {
-  let Category = DocCatVariable;
-  let Heading = "intel::max_concurrency";
-  let Content = [{
-This attribute applies to a loop or a function. It indicates that the
-loop/function should allow no more than N threads or iterations to execute it
-simultaneously. N must be a non negative integer. '0' indicates the
-max_concurrency case to be unbounded. Cannot be applied multiple times to the
-same loop or function, or in conjunction with ``disable_loop_pipelining``.
-
-.. code-block:: c++
-
-  void foo() {
-    int a[10];
-    [[intel::max_concurrency(2)]] for (int i = 0; i != 10; ++i) a[i] = 0;
-  }
-
-  [[intel::max_concurrency(2)]] void foo1 { }
-  template<int N>
-  void bar() {
-    [[intel::max_concurrency(N)]] for(;;) { }
-  }
-  template<int N>
-  [[intel::max_concurrency(N)]] void bar1() { }
-
-  }];
-}
-
 def SYCLIntelLoopCoalesceAttrDocs : Documentation {
   let Category = DocCatVariable;
   let Heading = "intel::loop_coalesce";
@@ -4154,28 +4052,6 @@ of the nested loop levels should be coalesced.
   }];
 }
 
-def SYCLIntelDisableLoopPipeliningAttrDocs : Documentation {
-  let Category = DocCatVariable;
-  let Heading = "intel::disable_loop_pipelining";
-  let Content = [{
-This attribute applies to a loop or a function. Takes no arguments and
-indicates whether the kernel should be pipelined or not. Cannot be used on the
-same loop or function, or in conjunction with ``speculated_iterations``,
-``max_concurrency``, ``initiation_interval``, ``ivdep``,
-``max_reinvocation_delay`` or ``enable_loop_pipelining`` attribute.
-
-.. code-block:: c++
-
-  void foo() {
-    int var = 0;
-    [[intel::disable_loop_pipelining]] for (int i = 0; i < 10; ++i) var++;
-  }
-
-  [[intel::disable_loop_pipelining]] void foo1() { }
-
-  }];
-}
-
 def SYCLIntelMaxInterleavingAttrDocs : Documentation {
   let Category = DocCatVariable;
   let Heading = "intel::max_interleaving";
@@ -4201,31 +4077,6 @@ Parameter N is mandatory, and may either be 0, or 1.
   }];
 }
 
-def SYCLIntelSpeculatedIterationsAttrDocs : Documentation {
-  let Category = DocCatVariable;
-  let Heading = "intel::speculated_iterations";
-  let Content = [{
-This attribute applies to a loop. Specifies the number of concurrent speculated
-iterations that will be in flight for a loop invocation (i.e. the exit
-condition for these iterations will not have been evaluated yet).
-Parameter N is mandatory, and may either be 0, or a positive integer. Cannot be
-used on the same loop in conjunction with disable_loop_pipelining.
-
-.. code-block:: c++
-
-  void foo() {
-    int var = 0;
-    [[intel::speculated_iterations(4)]] for (int i = 0; i < 10; ++i) var++;
-  }
-
-  template<int N>
-  void bar() {
-    [[intel::speculated_iterations(N)]] for(;;) { }
-  }
-
-  }];
-}
-
 def SYCLIntelNofusionAttrDocs : Documentation {
   let Category = DocCatVariable;
   let Heading = "intel::nofusion";
@@ -4250,68 +4101,6 @@ loop should not be fused with any adjacent loop.
   }];
 }
 
-def SYCLIntelMaxReinvocationDelayAttrDocs : Documentation {
-  let Category = DocCatVariable;
-  let Heading = "intel::max_reinvocation_delay";
-  let Content = [{
-This attribute applies to a loop. Specifies the maximum number of cycles allowed
-on the delay between the launch of the last iteration of a loop invocation and
-the launch of the first iteration of a new loop invocation. Parameter N is
-mandatory, and is a positive integer. Cannot be used on the same loop in
-conjunction with disable_loop_pipelining.
-
-.. code-block:: c++
-
-  void foo() {
-    int var = 0;
-    [[intel::max_reinvocation_delay(1)]]
-    for (int i = 0; sycl::log10((float)(x)) < 10; i++) var++;
-  }
-
-  template<int N>
-  void bar() {
-    [[intel::max_reinvocation_delay(N)]] for(;;) { }
-  }
-  }];
-}
-
-def SYCLIntelEnableLoopPipeliningAttrDocs : Documentation {
-  let Category = DocCatVariable;
-  let Heading = "intel::enable_loop_pipelining";
-  let Content = [{
-The ``enable_loop_pipelining`` attribute applies to a loop in SYCL device code.
-Takes no arguments and enables pipelining of the loop. This attribute is useful
-in the low-area flow, in which all loops are unpipelined by default. Cannot be
-used on the same loop in conjunction with ``disable_loop_pipelining`` attribute.
-
-.. code-block:: c++
-
-  void bar() {
-    int a[10];
-    [[[intel::enable_loop_pipelining]] for (int i = 0; i != 10; ++i) a[i] = 0;
-  }
-
-  void Array(int *array, size_t n) {
-    [[intel::enable_loop_pipelining]] for (int i = 0; i < n; ++i) array[i] = 0;
-  }
-
-  void count () {
-    int a1[10], i = 0;
-    [[intel::enable_loop_pipelining]] while (i < 10) {
-      a1[i++] = 3;
-    }
-  }
-
-  void check() {
-    int a = 10;
-    [[intel::enable_loop_pipelining]] do {
-      a = a + 1;
-    } while (a < 20);
-  }
-
-  }];
-}
-
 def SYCLIntelLoopFuseDocs : Documentation {
   let Category = DocCatFunction;
   let Heading = "loop_fuse, loop_fuse_independent";