[DOC] Fix `load` instructions' syntax, function definition.

[Higuoxing]

Summary

In this patch, I updated load instruction syntax and fixed function definition. Besides, I re-named some variables to make them obey SSA rule.

llvm/docs/GetElementPtr.rst

.. code-block:: c++
   struct munger_struct {
     int f1;
     int f2;
   };
   void munge(struct munger_struct *P) {
     P[0].f1 = P[1].f1 + P[2].f2;
   }
   ...
-  munger_struct Array[3];
+  struct munger_struct Array[3];
   ...
   munge(Array);
 
 In this "C" example, the front end compiler (Clang) will generate three GEP
 instructions for the three indices through "P" in the assignment statement.  The
 function argument ``P`` will be the second operand of each of these GEP
 instructions.  The third operand indexes through that pointer.  The fourth
 operand will be the field offset into the ``struct munger_struct`` type, for
 either the ``f1`` or ``f2`` field. So, in LLVM assembly the ``munge`` function
 looks like:
 
 .. code-block:: llvm
 
-  void %munge(%struct.munger_struct* %P) {
+  define void @munge(%struct.munger_struct* %P) {
   entry:
     %tmp = getelementptr %struct.munger_struct, %struct.munger_struct* %P, i32 1, i32 0
-    %tmp = load i32* %tmp
-    %tmp6 = getelementptr %struct.munger_struct, %struct.munger_struct* %P, i32 2, i32 1
-    %tmp7 = load i32* %tmp6
-    %tmp8 = add i32 %tmp7, %tmp
-    %tmp9 = getelementptr %struct.munger_struct, %struct.munger_struct* %P, i32 0, i32 0
-    store i32 %tmp8, i32* %tmp9
+    %tmp1 = load i32, i32* %tmp
+    %tmp2 = getelementptr %struct.munger_struct, %struct.munger_struct* %P, i32 2, i32 1
+    %tmp3 = load i32, i32* %tmp2
+    %tmp4 = add i32 %tmp3, %tmp1
+    %tmp5 = getelementptr %struct.munger_struct, %struct.munger_struct* %P, i32 0, i32 0
+    store i32 %tmp4, i32* %tmp5
     ret void
   }
 
 In each case the second operand is the pointer through which the GEP instruction
 starts. The same is true whether the second operand is an argument, allocated
 memory, or a global variable.
 
 To make this clear, let's consider a more obtuse example:

 illegal.
 
 In order to access the 18th integer in the array, you would need to do the
 following:
 
 .. code-block:: text
 
   %idx = getelementptr { [40 x i32]* }, { [40 x i32]* }* %, i64 0, i32 0
-  %arr = load [40 x i32]** %idx
+  %arr = load [40 x i32]*, [40 x i32]** %idx
   %idx = getelementptr [40 x i32], [40 x i32]* %arr, i64 0, i64 17
 
 In this case, we have to load the pointer in the structure with a load
 instruction before we can index into the array. If the example was changed to:
 
 .. code-block:: text
 
   %MyVar = uninitialized global { [40 x i32 ] }