Reformulate OrcJIT tutorial doc to make it more clear.

[sonson]

Summary

Fixed a minor writing error. The text was hard to understand, so I reviewed it.

[mehdi_amini]

LGTM, can you retitle to something descriptive, for example Reformulate OrcJIT tutorial doc to make it more clear or something like that?

Also do you have commit access or do you need someone to land this for you?

[sonson]

I changed the title and I will keep it in mind about titles.
I do not have commit access, I need someone to land it.

Thank you for your review.

llvm/docs/tutorial/BuildingAJIT2.rst

 
 This code, from ``llvm/lib/ExecutionEngine/Orc/Layer.cpp``, adds a
 ThreadSafeModule to a given JITDylib by wrapping it up in a
 ``MaterializationUnit`` (in this case a ``BasicIRLayerMaterializationUnit``).
 Most layers that derived from IRLayer can rely on this default implementation
 of the ``add`` method.
 
 These two operations, ``add`` and ``emit``, together constitute the layer
-concept: A layer is a way to wrap a portion of a compiler pipeline (in this case
-the "opt" phase of an LLVM compiler) whose API is is opaque to ORC in an
-interface that allows ORC to invoke it when needed. The add method takes an
+concept: A layer is a way to wrap a part of a compiler pipeline (in this case
+the "opt" phase of an LLVM compiler) whose API is opaque to ORC with an
+interface that ORC can call as needed. The add method takes an
 module in some input program representation (in this case an LLVM IR module) and
 stores it in the target JITDylib, arranging for it to be passed back to the
 Layer's emit method when any symbol defined by that module is requested. Layers
 can compose neatly by calling the 'emit' method of a base layer to complete
 their work. For example, in this tutorial our IRTransformLayer calls through to
 our IRCompileLayer to compile the transformed IR, and our IRCompileLayer in turn
 calls our ObjectLayer to link the object file produced by our compiler.