[clang] NFC: return void in an alternative expression after call to void function.

[zhouyizhou]

Summary

It is better to return void in an alternative expression after call to void function. Also, I processed emitDestroy's function body using clang-format.

I don't have write access to LLVM repository, if the patch got approved, can someone commit for me ?

Thanks
Zhouyi

Signed-off-by: Zhouyi Zhou <[e-mail]>

[zhouyizhou]

I create this patch because I am also a Linux hobbyist, in Linux kernel, return statement in a void function is always standalone. For example in kernel/event/core.c:

static void
perf_event_exit_event(struct perf_event *child_event,

struct perf_event_context *child_ctx,
struct task_struct *child)

{

...
if (!parent_event) {
        perf_event_wakeup(child_event);
        return;
}
...

}

In above code, return statement is standalone. It was rarely seen statement like "return perf_event_wakeup(child_event);" in Linux kernel.

Thanks
Zhouyi

[zhouyizhou]

ping
Just a ping, to see if there are any comments :-P

clang/lib/CodeGen/CGDecl.cpp

 ///   elements
 /// \param useEHCleanupForArray - whether an EH cleanup should be
 ///   used when destroying array elements, in case one of the
 ///   destructions throws an exception
 void CodeGenFunction::emitDestroy(Address addr, QualType type,
                                   Destroyer *destroyer,
                                   bool useEHCleanupForArray) {
   const ArrayType *arrayType = getContext().getAsArrayType(type);
-  if (!arrayType)
-    return destroyer(*this, addr, type);
+  if (!arrayType) {
+    destroyer(*this, addr, type);
+    return;
+  }
 
   llvm::Value *length = emitArrayLength(arrayType, type, addr);
 
-  CharUnits elementAlign =
-    addr.getAlignment()
-        .alignmentOfArrayElement(getContext().getTypeSizeInChars(type));
+  CharUnits elementAlign = addr.getAlignment().alignmentOfArrayElement(
+      getContext().getTypeSizeInChars(type));
 
   // Normally we have to check whether the array is zero-length.
   bool checkZeroLength = true;
 
   // But if the array length is constant, we can suppress that.
   if (llvm::ConstantInt *constLength = dyn_cast<llvm::ConstantInt>(length)) {
     // ...and if it's constant zero, we can just skip the entire thing.
-    if (constLength->isZero()) return;
+    if (constLength->isZero())
+      return;
     checkZeroLength = false;
   }
 
   llvm::Value *begin = addr.getPointer();
   llvm::Value *end =
       Builder.CreateInBoundsGEP(addr.getElementType(), begin, length);
-  emitArrayDestroy(begin, end, type, elementAlign, destroyer,
-                   checkZeroLength, useEHCleanupForArray);
+  emitArrayDestroy(begin, end, type, elementAlign, destroyer, checkZeroLength,
+                   useEHCleanupForArray);
 }
 
 /// emitArrayDestroy - Destroys all the elements of the given array,
 /// beginning from last to first.  The array cannot be zero-length.
 ///
 /// \param begin - a type* denoting the first element of the array
 /// \param end - a type* denoting one past the end of the array
 /// \param elementType - the element type of the array