[docs] Fix load instructions in chapter 7 of the tutorial

[klao]

Summary

Loads in the first half of the chapter are missing the type argument.

[xgupta]

Need to commit by someone? CC @Jim

llvm/docs/tutorial/MyFirstLanguageFrontend/LangImpl07.rst

.. code-block:: llvm
     @G = weak global i32 0   ; type of @G is i32*
     @H = weak global i32 0   ; type of @H is i32*
 
     define i32 @test(i1 %Condition) {
     entry:
       br i1 %Condition, label %cond_true, label %cond_false
 
     cond_true:
-      %X.0 = load i32* @G
+      %X.0 = load i32, i32* @G
       br label %cond_next
 
     cond_false:
-      %X.1 = load i32* @H
+      %X.1 = load i32, i32* @H
       br label %cond_next
 
     cond_next:
       %X.2 = phi i32 [ %X.1, %cond_false ], [ %X.0, %cond_true ]
       ret i32 %X.2
     }
 
 In this example, the loads from the G and H global variables are

 instruction <../../LangRef.html#alloca-instruction>`_:
 
 .. code-block:: llvm
 
     define i32 @example() {
     entry:
       %X = alloca i32           ; type of %X is i32*.
       ...
-      %tmp = load i32* %X       ; load the stack value %X from the stack.
+      %tmp = load i32, i32* %X  ; load the stack value %X from the stack.
       %tmp2 = add i32 %tmp, 1   ; increment it
       store i32 %tmp2, i32* %X  ; store it back
       ...
 
 This code shows an example of how you can declare and manipulate a stack
 variable in the LLVM IR. Stack memory allocated with the alloca
 instruction is fully general: you can pass the address of the stack slot
 to functions, you can store it in other variables, etc. In our example
 above, we could rewrite the example to use the alloca technique to avoid
 using a PHI node:
 
 .. code-block:: llvm
 
     @G = weak global i32 0   ; type of @G is i32*
     @H = weak global i32 0   ; type of @H is i32*
 
     define i32 @test(i1 %Condition) {
     entry:
       %X = alloca i32           ; type of %X is i32*.
       br i1 %Condition, label %cond_true, label %cond_false
 
     cond_true:
-      %X.0 = load i32* @G
+      %X.0 = load i32, i32* @G
       store i32 %X.0, i32* %X   ; Update X
       br label %cond_next
 
     cond_false:
-      %X.1 = load i32* @H
+      %X.1 = load i32, i32* @H
       store i32 %X.1, i32* %X   ; Update X
       br label %cond_next
 
     cond_next:
-      %X.2 = load i32* %X       ; Read X
+      %X.2 = load i32, i32* %X  ; Read X
       ret i32 %X.2
     }
 
 With this, we have discovered a way to handle arbitrary mutable
 variables without the need to create Phi nodes at all:
 
 #. Each mutable variable becomes a stack allocation.
 #. Each read of the variable becomes a load from the stack.
.. code-block:: bash
     @G = weak global i32 0
     @H = weak global i32 0
 
     define i32 @test(i1 %Condition) {
     entry:
       br i1 %Condition, label %cond_true, label %cond_false
 
     cond_true:
-      %X.0 = load i32* @G
+      %X.0 = load i32, i32* @G
       br label %cond_next
 
     cond_false:
-      %X.1 = load i32* @H
+      %X.1 = load i32, i32* @H
       br label %cond_next
 
     cond_next:
       %X.01 = phi i32 [ %X.1, %cond_false ], [ %X.0, %cond_true ]
       ret i32 %X.01
     }
 
 The mem2reg pass implements the standard "iterated dominance frontier"