Polish comments prose in processor.h (#44161)

Author: timholy

src/processor.h

@@ -14,9 +14,9 @@ extern "C" {
 /**
  * Related sysimg exported symbols
  *
- * In the following text function refer to an abstract identity.
- * It corresponds to a `Function` that we emit in the codegen and there might be multiple copy
- * of it in the system image. Only one of those copy will be used in a given session.
+ * In the following text, function refers to an abstract entity.
+ * It corresponds to a `Function` that we emit in the codegen, and there might be multiple copies
+ * of it in the system image. Only one of those copies will be used in a given session.
  * Function pointers refer to a real piece of code in the system image.
  * Each function might have multiple function pointers in the system image
  * and each function pointer will correspond to only one function.
@@ -34,28 +34,28 @@ extern "C" {
  *     The default function pointer is used if the function is cloned.
  *     The first element is the size of the array, which should **NOT** be used as the number
  *     of julia functions in the sysimg.
- *     Each entry in this array uniquely identifies a function which we are interested in
+ *     Each entry in this array uniquely identifies a function we are interested in
  *     (the function may have multiple function pointers corresponding to different versions).
- *     In other sysimg info, all information of functions are stored as function index which are
- *     `uint32_t` index in this array.
+ *     In other sysimg info, all references to functions are stored as their `uint32_t` index
+ *     in this array.
  *
  * # Target data and dispatch slots (Only needed by runtime during loading)
  * `jl_dispatch_target_ids`: [static data] serialize target data.
  *     This contains the number of targets which is needed to decode `jl_dispatch_fvars_idxs`
- *     in additional to the name and feature set of each target.
+ *     in addition to the name and feature set of each target.
  * `jl_dispatch_reloc_slots`: [static data] location and index of relocation slots.
  *     Stored as pairs of function indices and `int32_t` offsets from `jl_sysimg_gvars_base`.
  *     The first element is an `uint32_t` giving the number of relocations.
  *     This is needed for functions whose address is used in a way that requires dispatch.
  *     We currently only support one type of relocation (i.e. absolute pointer) which is enough
- *     for all use in functions as well as global GOT slot (for "PLT" callback).
+ *     for all use in functions as well as GOT slot (for "PLT" callback).
  *     Note that not all functions being cloned are assigned a slot.
  *     This array is sorted by the function indices.
  *     There can be more than one slot per-function,
  *     i.e. there can be duplicated function indices.
  *
  * # Target functions
- * `jl_dispatch_fvars_idxs`: [static data] Target specific functions indices.
+ * `jl_dispatch_fvars_idxs`: [static data] Target-specific function indices.
  *     For each target, this includes a tagged `uint32_t` length, an optional `uint32_t` index
  *     of the base target followed by an array of tagged function indices.
  *     The base target index is required to be smaller than the index of the current target
@@ -74,25 +74,25 @@ extern "C" {
  *     the base one since this is the only way we currently represent relocations.)
  *     A tagged length implicitly tags all the indices and the indices will not have the tag bit
  *     set. The lengths in this variable is needed to decode `jl_dispatch_fvars_offsets`.
- * `jl_dispatch_fvars_offsets`: [static data] Target specific function pointer offsets.
- *     This contains all the cloned functions that we are interested and it needs to be decoded
+ * `jl_dispatch_fvars_offsets`: [static data] Target-specific function pointer offsets.
+ *     This contains all the cloned functions that we are interested in and it needs to be decoded
  *     and used along with `jl_dispatch_fvars_idxs`.
  *     For the default target, there's no entries in this variable, if there's any relocations
  *     needed for the default target, the function pointers are taken from the global offset
  *     arrays directly.
  *     For a `clone_all` target (i.e. with the length in `jl_dispatch_fvars_idxs` tagged), this
- *     variable contains an offset array the same length as the global one. Only the indices
- *     appeared in `jl_dispatch_fvars_idxs` needs relocation and the dispatch code should return
+ *     variable contains an offset array of the same length as the global one. Only the indices
+ *     appearing in `jl_dispatch_fvars_idxs` need relocation and the dispatch code should return
  *     this array as the original/base function offsets.
  *     For other targets, this variable contains an offset array with the length defined in
- *     `jl_dispatch_fvars_idxs`. Tagged indices needs relocations.
+ *     `jl_dispatch_fvars_idxs`. Tagged indices need relocations.
  */
 
 enum {
     JL_TARGET_VEC_CALL = 1 << 0,
     // Clone all functions
     JL_TARGET_CLONE_ALL = 1 << 1,
-    // Clone when there's scalar math operations that can benefit from target specific
+    // Clone when there's scalar math operations that can benefit from target-specific
     // optimizations. This includes `muladd`, `fma`, `fast`/`contract` flags.
     JL_TARGET_CLONE_MATH = 1 << 2,
     // Clone when the function has a loop