[Documentation][NFC] Remove invalid language specifiers in markdown code blocks

Author: cor3ntin

flang/docs/ComplexOperations.md

@@ -35,7 +35,7 @@ end function pow_self
 ```
 
 **FIR**
-```c
+```
 func.func @_QPpow_self(%arg0: !fir.ref<!fir.complex<4>>) -> !fir.complex<4> {
     %0 = fir.alloca !fir.complex<4>
     %1 = fir.load %arg0 : !fir.ref<!fir.complex<4>>

flang/docs/FIRArrayOperations.md

@@ -1,9 +1,9 @@
-<!--===- docs/FIRArrayOperations.md 
-  
+<!--===- docs/FIRArrayOperations.md
+
    Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
    See https://llvm.org/LICENSE.txt for license information.
    SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-  
+
 -->
 
 # Design: FIR Array operations
@@ -19,7 +19,7 @@ local:
 The array operations in FIR model the copy-in/copy-out semantics over Fortran
 statements.
 
-Fortran language semantics sometimes require the compiler to make a temporary 
+Fortran language semantics sometimes require the compiler to make a temporary
 copy of an array or array slice. Situations where this can occur include:
 
 * Passing a non-contiguous array to a procedure that does not declare it as
@@ -40,7 +40,7 @@ There are currently the following operations:
 `array_load`(s) and `array_merge_store` are a pairing that brackets the lifetime
 of the array copies.
 
-`array_fetch` and `array_update` are defined to work as getter/setter pairs on 
+`array_fetch` and `array_update` are defined to work as getter/setter pairs on
 values of elements from loaded array copies. These have "GEP-like" syntax and
 semantics.
 
@@ -83,7 +83,7 @@ alter its composite value. This operation lets one load an array as a
 value while applying a runtime shape, shift, or slice to the memory
 reference, and its semantics guarantee immutability.
 
-```mlir
+```
 %s = fir.shape_shift %lb1, %ex1, %lb2, %ex2 : (index, index, index, index) -> !fir.shapeshift<2>
 // load the entire array 'a'
 %v = fir.array_load %a(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>) -> !fir.array<?x?xf32>
@@ -92,7 +92,7 @@ reference, and its semantics guarantee immutability.
 
 # array_merge_store
 
-The `array_merge_store` operation stores a merged array value to memory. 
+The `array_merge_store` operation stores a merged array value to memory.
 
 
 ```fortran
@@ -104,7 +104,7 @@ The `array_merge_store` operation stores a merged array value to memory.
 One can use `fir.array_merge_store` to merge/copy the value of `a` in an
 array expression as shown above.
 
-```mlir
+```
   %v = fir.array_load %a(%shape) : ...
   %r = fir.array_update %v, %f, %i, %j : (!fir.array<?x?xf32>, f32, index, index) -> !fir.array<?x?xf32>
   fir.array_merge_store %v, %r to %a : !fir.ref<!fir.array<?x?xf32>>
@@ -137,7 +137,7 @@ One can use `fir.array_fetch` to fetch the (implied) value of `a(i,j)` in
 an array expression as shown above. It can also be used to extract the
 element `a(r,s+1)` in the second expression.
 
-```mlir
+```
   %s = fir.shape %n, %m : (index, index) -> !fir.shape<2>
   // load the entire array 'a'
   %v = fir.array_load %a(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>
@@ -165,7 +165,7 @@ the update.
 One can use `fir.array_update` to update the (implied) value of `a(i,j)`
 in an array expression as shown above.
 
-```mlir
+```
   %s = fir.shape %n, %m : (index, index) -> !fir.shape<2>
   // load the entire array 'a'
   %v = fir.array_load %a(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>
@@ -206,7 +206,7 @@ the element `a(i,j)` in an array expression `a` as shown above. It can also
 be used to recover the reference element `a(r,s+1)` in the second
 expression.
 
-```mlir
+```
   %s = fir.shape %n, %m : (index, index) -> !fir.shape<2>
   // load the entire array 'a'
   %v = fir.array_load %a(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>
@@ -220,9 +220,9 @@ source. Other array operation such as `array_amend` can be in between.
 
 `array_access` if mainly used with `character`'s arrays and arrays of derived
 types where because they might have a non-compile time sizes that would be
-useless too load entirely or too big to load. 
+useless too load entirely or too big to load.
 
-Here is a simple example with a `character` array assignment. 
+Here is a simple example with a `character` array assignment.
 
 Fortran
 ```
@@ -271,12 +271,12 @@ it has dynamic length, and even if constant, could be too long to do so.
 
 ## array_amend
 
-The `array_amend` operation marks an array value as having been changed via a 
+The `array_amend` operation marks an array value as having been changed via a
 reference obtain by an `array_access`. It acts as a logical transaction log
 that is used to merge the final result back with an `array_merge_store`
 operation.
 
-```mlir
+```
   // fetch the value of one of the array value's elements
   %1 = fir.array_access %v, %i, %j : (!fir.array<?x?xT>, index, index) -> !fir.ref<T>
   // modify the element by storing data using %1 as a reference
@@ -317,7 +317,7 @@ func @_QPs(%arg0: !fir.box<!fir.array<?x!fir.type<_QFsTt{m:i32}>>>, %arg1: !fir.
   // This is the "seed" for the "copy-out" array on the LHS. It'll flow from iteration to iteration and gets
   // updated at each iteration.
   %array_a_dest_init = fir.array_load %arg0 : (!fir.box<!fir.array<?x!fir.type<_QFsTt{m:i32}>>>) -> !fir.array<?x!fir.type<_QFsTt{m:i32}>>
-  
+
   %array_a_final = fir.do_loop %i = %l_index to %u_index step %c1 unordered iter_args(%array_a_dest = %array_a_dest_init) -> (!fir.array<?x!fir.type<_QFsTt{m:i32}>>) {
     // Compute indexing for the RHS and array the element.
     %u_minus_i = arith.subi %u_index, %i : index // u-i

flang/docs/HighLevelFIR.md

@@ -119,7 +119,7 @@ its first operand to return an HLFIR variable compatible type.
 The fir.declare op is the only operation described by this change that will be
 added to FIR. The rational for this is that it is intended to survive until
 LLVM dialect codegeneration so that debug info generation can use them and
-alias information can take advantage of them even on FIR. 
+alias information can take advantage of them even on FIR.
 
 Note that Fortran variables are not necessarily named objects, they can also be
 the result of function references returning POINTERs. hlfir.declare will also
@@ -1021,7 +1021,7 @@ end subroutine
 
 Lowering output:
 
-```HLFIR
+```
 func.func @_QPfoo(%arg0: !fir.box<!fir.array<?xf32>>, %arg1: !fir.box<!fir.array<?xf32>>) {
   %a = hlfir.declare %arg0 {fir.def = "_QPfooEa"} : !fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>
   %b = hlfir.declare %arg1 {fir.def = "_QPfooEb"} : !fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>
@@ -1107,7 +1107,7 @@ end subroutine
 
 Lowering output:
 
-```HLFIR
+```
 func.func @_QPfoo(%arg0: !fir.box<!fir.array<?xf32>>, %arg1: !fir.box<!fir.array<?xf32>>, %arg2: !fir.box<!fir.ptr<!fir.array<?xf32>>>, %arg3: !fir.ref<!fir.array<100xf32>>) {
   %a = hlfir.declare %arg0 {fir.def = "_QPfooEa"} {fir.target} : !fir.box<!fir.array<?xf32>, !fir.box<!fir.array<?xf32>
   %b =  hlfir.declare %arg1 {fir.def = "_QPfooEb"} : !fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>
@@ -1145,7 +1145,7 @@ Step 1: hlfir.elemental inlining: inline the first hlfir.elemental into the
 second one at the hlfir.apply.
 
 
-```HLFIR
+```
 func.func @_QPfoo(%arg0: !fir.box<!fir.array<?xf32>>, %arg1: !fir.box<!fir.array<?xf32>>, %arg2: !fir.box<!fir.ptr<!fir.array<?xf32>>>, %arg3: !fir.ref<!fir.array<100xf32>>) {
   %a = hlfir.declare %arg0 {fir.def = "_QPfooEa"} {fir.target} : !fir.box<!fir.array<?xf32>, !fir.box<!fir.array<?xf32>
   %b =  hlfir.declare %arg1 {fir.def = "_QPfooEb"} : !fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>
@@ -1190,7 +1190,7 @@ Note that the alias analysis could have already occurred without inlining the
 %add hlfir.elemental.
 
 
-```HLFIR
+```
 func.func @_QPfoo(%arg0: !fir.box<!fir.array<?xf32>>, %arg1: !fir.box<!fir.array<?xf32>>, %arg2: !fir.box<!fir.ptr<!fir.array<?xf32>>>, %arg3: !fir.ref<!fir.array<100xf32>>) {
   %a = hlfir.declare %arg0 {fir.def = "_QPfooEa"} {fir.target} : !fir.box<!fir.array<?xf32>, !fir.box<!fir.array<?xf32>
   %b =  hlfir.declare %arg1 {fir.def = "_QPfooEb"} : !fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>
@@ -1229,7 +1229,7 @@ func.func @_QPfoo(%arg0: !fir.box<!fir.array<?xf32>>, %arg1: !fir.box<!fir.array
 Step 4: Lower assignments to regular loops since they have the no_overlap
 attribute, and inline the hlfir.elemental into the first loop nest.
 
-```HLFIR
+```
 func.func @_QPfoo(%arg0: !fir.box<!fir.array<?xf32>>, %arg1: !fir.box<!fir.array<?xf32>>, %arg2: !fir.box<!fir.ptr<!fir.array<?xf32>>>, %arg3: !fir.ref<!fir.array<100xf32>>) {
   %a = hlfir.declare %arg0 {fir.def = "_QPfooEa"} {fir.target} : !fir.box<!fir.array<?xf32>, !fir.box<!fir.array<?xf32>
   %b =  hlfir.declare %arg1 {fir.def = "_QPfooEb"} : !fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>
@@ -1275,7 +1275,7 @@ Step 5 (may also occur earlier or several times): shape propagation.
     conformance checks can be added for %a, %b and %p.
 -   %temp is small, and its fir.allocmem can be promoted to a stack allocation
 
-```HLFIR
+```
 func.func @_QPfoo(%arg0: !fir.box<!fir.array<?xf32>>, %arg1: !fir.box<!fir.array<?xf32>>, %arg2: !fir.box<!fir.ptr<!fir.array<?xf32>>>, %arg3: !fir.ref<!fir.array<100xf32>>) {
   // .....
   %cshape = fir.shape %c100
@@ -1366,7 +1366,7 @@ the MLIR infrastructure experience that was gained.
 
 ## Using symbols for HLFIR variables
 
-### Using attributes as pseudo variable symbols 
+### Using attributes as pseudo variable symbols
 
 Instead of restricting the memory types an HLFIR variable can have, it was
 force the defining operation of HLFIR variable SSA values to always be

flang/docs/ParameterizedDerivedTypes.md

@@ -96,7 +96,7 @@ In case of `len_type1`, the size, offset, etc. of `fld1` and `fld2` depend on
 the runtime values of `i` and `j` when the components are inlined into the
 derived type. At runtime, this information needs to be computed to be retrieved.
 While lowering the PDT, compiler generated functions can be created in order to
-compute this information. 
+compute this information.
 
 Note: The type description tables generated by semantics and used throughout the
 runtime have component offsets as constants. Inlining component would require
@@ -127,7 +127,7 @@ type len_type2(i, j)
   ! allocatable components managed by the compiler. The
   ! `compiler_managed_allocatable` is not a proper keyword but just added here
   ! to have a better understanding.
-  character(i+j), compiler_managed_allocatable :: fld1 
+  character(i+j), compiler_managed_allocatable :: fld1
   character(j-i+2), compiler_managed_allocatable :: fld2
 end type
 ```
@@ -266,7 +266,7 @@ the offset of `fld1` in `len_type1` could be 0; its size would be computed as
 function.
 
 **FIR**
-```c
+```
 // Example of compiler generated functions to compute offsets, size, etc.
 // This is just an example and actual implementation might have more functions.
 
@@ -337,7 +337,7 @@ pdt_inlined_array(1)%field%fld2
 ```
 
 Example of offset computation in the PDTs.
-```c
+```
 %0 = call @_len_type3.field.typeparam.1(%i, %j) : (index, index) -> index
 %1 = call @_len_type3.field.typeparam.2(%i, %j) : (index, index) -> index
 %2 = call @_len_type3.offset.fld(%i, %j) : (index, index) -> index
@@ -367,7 +367,7 @@ operation can take the length type parameters needed for size/offset
 computation.
 
 **FIR**
-```c
+```
 %5 = fir.field_index i, !fir.type<_QMmod1Tt{l:i32,i:!fir.array<?xi32>}>(%n : i32)
 ```
 
@@ -431,7 +431,7 @@ allocate(t1(2)::p)
 ```
 
 **FIR**
-```c
+```
 // For allocatable
 %5 = fir.call @_FortranAAllocatableInitDerived(%desc, %type) : (!fir.box<none>, ) -> ()
 // The AllocatableSetDerivedLength functions is called for each length type parameters.
@@ -455,8 +455,8 @@ The `DEALLOCATE` statement is lowered to a runtime call to
 deallocate(pdt1)
 ```
 
-**FIR** 
-```c
+**FIR**
+```
 // For allocatable
 %8 = fir.call @_FortranAAllocatableDeallocate(%desc1) : (!fir.box<none>) -> (i32)
 
@@ -475,7 +475,7 @@ NULLIFY(p)
 ```
 
 **FIR**
-```c
+```
 %0 = fir.call @_FortranAPointerNullifyDerived(%desc, %type) : (!fir.box<none>, !fir.tdesc) -> ()
 ```
 
@@ -507,11 +507,11 @@ end subroutine
 ```
 
 **FIR**
-```c
+```
 func.func @_QMpdtPprint_pdt() {
   %l = arith.constant = 10
   %0 = fir.alloca !fir.type<_QMpdtTt{l:i32,i:!fir.array<?xi32>}> (%l : i32) {bindc_name = "x", uniq_name = "_QMpdt_initFlocalEx"}
-  %1 = fir.embox %0 : (!fir.ref<!fir.type<_QMpdtTt{l:i32,i:!fir.array<?xi32>}>>) (typeparams %l : i32) -> !fir.box<!fir.type<_QMpdt_initTt{l:i32,i:!fir.array<2xi32>}>> 
+  %1 = fir.embox %0 : (!fir.ref<!fir.type<_QMpdtTt{l:i32,i:!fir.array<?xi32>}>>) (typeparams %l : i32) -> !fir.box<!fir.type<_QMpdt_initTt{l:i32,i:!fir.array<2xi32>}>>
   %2 = fir.address_of(@_QQcl.2E2F6669725F7064745F6578616D706C652E66393000) : !fir.ref<!fir.char<1,22>>
   %c8_i32 = arith.constant 8 : i32
   %3 = fir.convert %1 : (!fir.box<!fir.type<_QMpdtTt{l:i32,i:!fir.array<?xi32>}>>) -> !fir.box<none>
@@ -564,7 +564,7 @@ type(t(10)) :: a, b
 type(t(20)) :: c
 type(t(:)), allocatable :: d
 a = b ! Legal assignment
-c = b ! Illegal assignment because `c` does not have the same length type 
+c = b ! Illegal assignment because `c` does not have the same length type
       ! parameter value than `b`.
 d = c ! Legal because `d` is allocatable
 ```
@@ -607,12 +607,12 @@ module m
   end type
 
 contains
-  
+
   subroutine finalize_t1s(x)
     type(t(kind(0.0))) x
     if (associated(x%vector)) deallocate(x%vector)
   END subroutine
-  
+
   subroutine finalize_t1v(x)
     type(t(kind(0.0))) x(:)
     do i = lbound(x,1), ubound(x,1)
@@ -832,7 +832,7 @@ allocating a PDT, the length type parameters are passed to the
 operation so its size can be computed accordingly.
 
 **FIR**
-```c
+```
 %i = arith.constant 10 : i32
 %0 = fir.alloca !fir.type<_QMmod1Tpdt{i:i32,data:!fir.array<?xf32>}> (%i : i32)
 // %i is the ssa value of the length type parameter
@@ -845,7 +845,7 @@ value of the given type. When creating a PDT, the length type parameters are
 passed so the size can be computed accordingly.
 
 **FIR**
-```c
+```
 %i = arith.constant 10 : i32
 %0 = fir.alloca !fir.type<_QMmod1Tpdt{i:i32,data:!fir.array<?xf32>}> (%i : i32)
 // ...
@@ -866,7 +866,7 @@ end subroutine
 ```
 
 **FIR**
-```c
+```
 func.func @_QMpdt_initPlocal() {
   %c2_i32 = arith.constant 2 : i32
   %0 = fir.alloca !fir.type<_QMpdt_initTt{l:i32,i:!fir.array<?xi32>}> (%c2 : i32)
@@ -892,7 +892,7 @@ a field identifier in a derived-type. The operation takes length type parameter
 values with a PDT so it can compute a correct offset.
 
 **FIR**
-```c
+```
 %l = arith.constant 10 : i32
 %1 = fir.field_index i, !fir.type<_QMpdt_initTt{l:i32,i:i32}> (%l : i32)
 %2 = fir.coordinate_of %ref, %1 : (!fir.type<_QMpdt_initTt{l:i32,i:i32}>, !fir.field) -> !fir.ref<i32>
@@ -905,7 +905,7 @@ return %3
 This operation is used to get the length type parameter offset in from a PDT.
 
 **FIR**
-```c
+```
 func.func @_QPpdt_len_value(%arg0: !fir.box<!fir.type<t1{l:i32,!fir.array<?xi32>}>>) -> i32 {
   %0 = fir.len_param_index l, !fir.box<!fir.type<t1{l:i32,!fir.array<?xi32>}>>
   %1 = fir.coordinate_of %arg0, %0 : (!fir.box<!fir.type<t1{l:i32,!fir.array<?xi32>}>>, !fir.len) -> !fir.ref<i32>
@@ -921,7 +921,7 @@ a memory location given the shape and LEN parameters of the result. Length type
 parameters is passed if the PDT is not boxed.
 
 **FIR**
-```c
+```
 func.func @return_pdt(%buffer: !fir.ref<!fir.type<t2(l1:i32,l2:i32){x:f32}>>) {
   %l1 = arith.constant 3 : i32
   %l2 = arith.constant 5 : i32
@@ -938,7 +938,7 @@ parameters operands. This is designed to use PDT without descriptor directly in
 FIR.
 
 **FIR**
-```c
+```
 // Operation used with a boxed PDT does not need the length type parameters as
 // they are directly retrieved from the box.
 %0 = fir.array_coor %boxed_pdt, %i, %j  (fir.box<fir.array<?x?xfir.type<!fir.type<_QMpdt_initTt{l:i32,i:!fir.array<?xi32>}>>>>, index, index) -> !fir.ref<fir.type<!fir.type<_QMpdt_initTt{l:i32,i:!fir.array<?xi32>}>>>