Fix typos in TargetLLVMIR.md

[xiaoleis]

Summary

Same as title.

[mehdi_amini]

Thanks, do you have commit access or should I land this for you?

[xiaoleis]

I do not have the commit access, could you help to land this? Thanks

mlir/docs/TargetLLVMIR.md

llvm.func @foo(%arg0: i32, %arg1: i64) -> !llvm.struct<(i32, i64)> {
   %1 = llvm.insertvalue %arg0, %0[0] : !llvm.struct<(i32, i64)>
   %2 = llvm.insertvalue %arg1, %1[1] : !llvm.struct<(i32, i64)>
 
   // return the structure value
   llvm.return %2 : !llvm.struct<(i32, i64)>
 }
 llvm.func @bar() {
   %0 = llvm.mlir.constant(42 : i32) : i32
-  %1 = llvm.mlir.constant(17) : i64
+  %1 = llvm.mlir.constant(17 : i64) : i64
 
   // call and extract the values from the structure
   %2 = llvm.call @bar(%0, %1)
      : (i32, i32) -> !llvm.struct<(i32, i64)>
   %3 = llvm.extractvalue %2[0] : !llvm.struct<(i32, i64)>
   %4 = llvm.extractvalue %2[1] : !llvm.struct<(i32, i64)>
 
   // use as before

 !llvm.memref_1d = !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1xi64>, array<1xi64>)>
 
 llvm.func @foo(%arg0: !llvm.ptr<f32>,  // Allocated pointer.
                %arg1: !llvm.ptr<f32>,  // Aligned pointer.
                %arg2: i64,             // Offset.
                %arg3: i64,             // Size in dim 0.
                %arg4: i64) {           // Stride in dim 0.
   // Populate memref descriptor structure.
-  %0 = llvm.mlir.undef :
+  %0 = llvm.mlir.undef : !llvm.memref_1d
   %1 = llvm.insertvalue %arg0, %0[0] : !llvm.memref_1d
   %2 = llvm.insertvalue %arg1, %1[1] : !llvm.memref_1d
   %3 = llvm.insertvalue %arg2, %2[2] : !llvm.memref_1d
   %4 = llvm.insertvalue %arg3, %3[3, 0] : !llvm.memref_1d
   %5 = llvm.insertvalue %arg4, %4[4, 0] : !llvm.memref_1d
 
   // Descriptor is now usable as a single value.
   "use"(%5) : (!llvm.memref_1d) -> ()

 -   `memref` types with all dimensions statically known.
 -   `memref` values allocated in such a way that the allocated and aligned
     pointer match. Alternatively, the same function must handle allocation and
     deallocation since only one pointer is passed to any callee.
 
 Examples:
 
 ```
-func.func @callee(memref<2x4xf32>) {
+func.func @callee(memref<2x4xf32>)
 
 func.func @caller(%0 : memref<2x4xf32>) {
   call @callee(%0) : (memref<2x4xf32>) -> ()
 }
 
 // ->
 
 !descriptor = !llvm.struct<(ptr<f32>, ptr<f32>, i64,
%offset = llvm.extractvalue[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64,
                                                array<4xi64>, array<4xi64>)>
 %addr7 = arith.addi %addr6, %offset : i64
 
 // All accesses are based on the aligned pointer.
 %aligned = llvm.extractvalue[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64,
                                                 array<4xi64>, array<4xi64>)>
 
 // Get the address of the data pointer.
-%ptr = llvm.getelementptr %aligned[%addr8]
+%ptr = llvm.getelementptr %aligned[%addr7]
      : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4xi64>, array<4xi64>)>
      -> !llvm.ptr<f32>
 
 // Perform the actual load.
 %0 = llvm.load %ptr : !llvm.ptr<f32>
 ```
 
 For stores, the address computation code is identical and only the actual store