[compiler-rt] Normalize some in/out doxygen parameter in interface headers. NFC.

[pgousseau]

Summary

LLVM coding standard recommend the in/out specifier to be placed before the parameter name.

compiler-rt/include/sanitizer/asan_interface.h

 /// If the return value is <c>global</c> or <c>stack</c>, tries to also return
 /// the variable name, address, and size. If the return value is <c>heap</c>,
 /// tries to return the chunk address and size. <c><i>name</i></c> should point
 /// to an allocated buffer of size <c><i>name_size</i></c>.
 ///
 /// \param addr Address to locate.
 /// \param name Buffer to store the variable's name.
 /// \param name_size Size in bytes of the variable's name buffer.
-/// \param region_address [out] Address of the region.
-/// \param region_size [out] Size of the region in bytes.
+/// \param[out] region_address Address of the region.
+/// \param[out] region_size Size of the region in bytes.
 ///
 /// \returns Returns the category of the given pointer as a constant string.
 const char *__asan_locate_address(void *addr, char *name, size_t name_size,
                                   void **region_address, size_t *region_size);
 
 /// Gets the allocation stack trace and thread ID for a heap address (useful
 /// for calling from the debugger).
 ///
 /// Stores up to <c><i>size</i></c> frames in <c><i>trace</i></c>. Returns
 /// the number of stored frames or 0 on error.
 ///
 /// \param addr A heap address.
 /// \param trace A buffer to store the stack trace.
 /// \param size Size in bytes of the trace buffer.
-/// \param thread_id [out] The thread ID of the address.
+/// \param[out] thread_id The thread ID of the address.
 ///
 /// \returns Returns the number of stored frames or 0 on error.
 size_t __asan_get_alloc_stack(void *addr, void **trace, size_t size,
                               int *thread_id);
 
 /// Gets the free stack trace and thread ID for a heap address (useful for
 /// calling from the debugger).
 ///
 /// Stores up to <c><i>size</i></c> frames in <c><i>trace</i></c>. Returns
 /// the number of stored frames or 0 on error.
 ///
 /// \param addr A heap address.
 /// \param trace A buffer to store the stack trace.
 /// \param size Size in bytes of the trace buffer.
-/// \param thread_id [out] The thread ID of the address.
+/// \param[out] thread_id The thread ID of the address.
 ///
 /// \returns Returns the number of stored frames or 0 on error.
 size_t __asan_get_free_stack(void *addr, void **trace, size_t size,
                              int *thread_id);
 
 /// Gets the current shadow memory mapping (useful for calling from the
 /// debugger).
 ///
-/// \param shadow_scale [out] Shadow scale value.
-/// \param shadow_offset [out] Offset value.
+/// \param[out] shadow_scale Shadow scale value.
+/// \param[out] shadow_offset Offset value.
 void __asan_get_shadow_mapping(size_t *shadow_scale, size_t *shadow_offset);
 
 /// This is an internal function that is called to report an error. However,
 /// it is still a part of the interface because you might want to set a
 /// breakpoint on this function in the debugger.
 ///
 /// \param pc <c><i>pc</i></c> value of the ASan error.
 /// \param bp <c><i>bp</i></c> value of the ASan error.

 ///
 /// If <c><i>beg</i></c> or <c><i>end</i></c> are NULL, they are not touched.
 ///
 /// \note This function can be called from a thread other than the owner of
 /// <c><i>fake_stack</i></c>, but the owner thread needs to be alive.
 ///
 /// \param fake_stack An opaque handler to a fake stack.
 /// \param addr Address to test.
-/// \param beg [out] Beginning of fake frame.
-/// \param end [out] End of fake frame.
+/// \param[out] beg Beginning of fake frame.
+/// \param[out] end End of fake frame.
 /// \returns Stack address or NULL.
 void *__asan_addr_is_in_fake_stack(void *fake_stack, void *addr, void **beg,
                                    void **end);
 
 /// Performs shadow memory cleanup of the current thread's stack before a
 /// function marked with the <c>[[noreturn]]</c> attribute is called.
 ///
 /// To avoid false positives on the stack, must be called before no-return

compiler-rt/include/sanitizer/common_interface_defs.h

 /// the <c>__sanitizer_start_switch_fiber()</c> function so that the fake stack
 /// is destroyed. If your program does not need stack use-after-return
 /// detection, you can always pass NULL to these two functions.
 ///
 /// \note The fake stack mechanism is disabled during fiber switch, so if a
 /// signal callback runs during the switch, it will not benefit from stack
 /// use-after-return detection.
 ///
-/// \param fake_stack_save [out] Fake stack save location.
+/// \param[out] fake_stack_save Fake stack save location.
 /// \param bottom Bottom address of stack.
 /// \param size Size of stack in bytes.
 void __sanitizer_start_switch_fiber(void **fake_stack_save,
                                     const void *bottom, size_t size);
 
 /// Notify ASan that a fiber switch has completed (required only if
 /// implementing your own fiber library).
 ///
 /// When code starts running on the new stack, it must call
 /// <c>__sanitizer_finish_switch_fiber()</c> to finalize
 /// the switch. For usage details, see the description of
 /// <c>__sanitizer_start_switch_fiber()</c>.
 ///
 /// \param fake_stack_save Fake stack save location.
-/// \param bottom_old [out] Bottom address of old stack.
-/// \param size_old [out] Size of old stack in bytes.
+/// \param[out] bottom_old Bottom address of old stack.
+/// \param[out] size_old Size of old stack in bytes.
 void __sanitizer_finish_switch_fiber(void *fake_stack_save,
                                      const void **bottom_old,
                                      size_t *size_old);
 
 // Get full module name and calculate pc offset within it.
 // Returns 1 if pc belongs to some module, 0 if module was not found.
 int __sanitizer_get_module_and_offset_for_pc(void *pc, char *module_path,
                                              size_t module_path_len,
                                              void **pc_offset);
 
 #ifdef __cplusplus
 }  // extern "C"
 #endif
 
 #endif  // SANITIZER_COMMON_INTERFACE_DEFS_H