Added comments

src/core/surface/call.c

@@ -424,6 +424,11 @@ static grpc_cq_completion *allocate_completion(grpc_call *call) {
     if (call->allocated_completions & (1u << i)) {
       continue;
     }
+    /* NB: the following integer arithmetic operation needs to be in its
+     * expanded form due to the "integral promotion" performed (see section
+     * 3.2.1.1 of the C89 draft standard), which in this case upcasts the result
+     * of the bitwise OR to "unsigned". A cast to the smaller container type is
+     * then required to avoid the compiler warning */
     call->allocated_completions =
         (gpr_uint8)(call->allocated_completions | (1u << i));
     gpr_mu_unlock(&call->completion_mu);
@@ -736,6 +741,11 @@ static void finish_live_ioreq_op(grpc_call *call, grpc_ioreq_op op,
   size_t i;
   /* ioreq is live: we need to do something */
   master = &call->masters[master_set];
+  /* NB: the following integer arithmetic operation needs to be in its
+   * expanded form due to the "integral promotion" performed (see section
+   * 3.2.1.1 of the C89 draft standard), which in this case upcasts the result
+   * of the bitwise OR to "unsigned". A cast to the smaller container type is
+   * then required to avoid the compiler warning */
   master->complete_mask = (gpr_uint16)(master->complete_mask | (1u << op));
   if (!success) {
     master->success = 0;
@@ -1246,6 +1256,11 @@ static grpc_call_error start_ioreq(grpc_call *call, const grpc_ioreq *reqs,
                            GRPC_MDSTR_REF(reqs[i].data.send_status.details));
       }
     }
+    /* NB: the following integer arithmetic operation needs to be in its
+     * expanded form due to the "integral promotion" performed (see section
+     * 3.2.1.1 of the C89 draft standard), which in this case upcasts the result
+     * of the bitwise OR to "unsigned". A cast to the smaller container type is
+     * then required to avoid the compiler warning */
     have_ops = (gpr_uint16)(have_ops | (1u << op));
 
     call->request_data[op] = data;
@@ -1831,4 +1846,3 @@ void *grpc_call_context_get(grpc_call *call, grpc_context_index elem) {
 }
 
 gpr_uint8 grpc_call_is_client(grpc_call *call) { return call->is_client; }
-

src/core/transport/chttp2/bin_encoder.c

@@ -185,6 +185,11 @@ gpr_slice grpc_chttp2_huffman_compress(gpr_slice input) {
   }
 
   if (temp_length) {
+    /* NB: the following integer arithmetic operation needs to be in its
+     * expanded form due to the "integral promotion" performed (see section
+     * 3.2.1.1 of the C89 draft standard), which in this case upcasts the result
+     * of the bitwise OR to "unsigned". A cast to the smaller container type is
+     * then required to avoid the compiler warning */
     *out++ = (gpr_uint8)((gpr_uint8)(temp << (8u - temp_length)) |
                          (gpr_uint8)(0xffu >> temp_length));
   }
@@ -265,6 +270,11 @@ gpr_slice grpc_chttp2_base64_encode_and_huffman_compress(gpr_slice input) {
   }
 
   if (out.temp_length) {
+    /* NB: the following integer arithmetic operation needs to be in its
+     * expanded form due to the "integral promotion" performed (see section
+     * 3.2.1.1 of the C89 draft standard), which in this case upcasts the result
+     * of the bitwise OR to "unsigned". A cast to the smaller container type is
+     * then required to avoid the compiler warning */
     *out.out++ = (gpr_uint8)((gpr_uint8)(out.temp << (8u - out.temp_length)) |
                              (gpr_uint8)(0xffu >> out.temp_length));
   }

tools/codegen/core/gen_hpack_tables.c

@@ -71,6 +71,11 @@ static unsigned char prefix_mask(unsigned char prefix_len) {
   unsigned char i;
   unsigned char out = 0;
   for (i = 0; i < prefix_len; i++) {
+    /* NB: the following integer arithmetic operation needs to be in its
+     * expanded form due to the "integral promotion" performed (see section
+     * 3.2.1.1 of the C89 draft standard), which in this case upcasts the result
+     * of the bitwise OR to "unsigned". A cast to the smaller container type is
+     * then required to avoid the compiler warning */
     out = (unsigned char)(out | (unsigned char)(1 << (7 - i)));
   }
   return out;
@@ -92,6 +97,11 @@ static void generate_first_byte_lut(void) {
     chrspec = NULL;
     for (j = 0; j < num_fields; j++) {
       if ((prefix_mask(fields[j].prefix_length) & i) == fields[j].prefix) {
+        /* NB: the following integer arithmetic operation needs to be in its
+         * expanded form due to the "integral promotion" performed (see section
+         * 3.2.1.1 of the C89 draft standard), which in this case upcasts the
+         * result of the bitwise AND to "unsigned". A cast to the smaller
+         * container type is then required to avoid the compiler warning */
         suffix = (unsigned char)(suffix_mask(fields[j].prefix_length) &
                                  (unsigned char)i);
         if (suffix == suffix_mask(fields[j].prefix_length)) {

tools/codegen/core/gen_legal_metadata_characters.c

@@ -41,6 +41,11 @@ static unsigned char legal_bits[256 / 8];
 static void legal(int x) {
   int byte = x / 8;
   int bit = x % 8;
+  /* NB: the following integer arithmetic operation needs to be in its
+   * expanded form due to the "integral promotion" performed (see section
+   * 3.2.1.1 of the C89 draft standard), which in this case upcasts the result
+   * of the bitwise OR to "unsigned". A cast to the smaller container type is
+   * then required to avoid the compiler warning */
   legal_bits[byte] =
       (unsigned char)((legal_bits[byte] | (unsigned char)(1 << bit)));
 }