[libFuzzer] Fix Sanitizer Coverage.

[mpividori]

Summary

This changes are related to the changes in compiler-rt to fix Sanitizer Coverage for Windows (https://reviews.llvm.org/D28432)
We need to export the functions when we want to change the default implementation.

[rnk]

Are we still planning to do this? You said this won't work in the static linking case, right?

[mpividori]

Hi, I took a different approach that will also work for MT. So I will abandon this diff, and I will soon submit the new one.

[kcc]

lib/Fuzzer/FuzzerTracePC.cpp

268

please put this into FuzzerDefs.h

269

Also, I think the name is wrong here, because these symbols are STRONG, not WEAK

[mpividori]

@kcc, I abandoned this diff and took a different approach. I will submit a new diff soon.
Thanks!

lib/Fuzzer/FuzzerTracePC.cpp

if (sizeof(T) == 4)
       TORC4.Insert(ArgXor, Arg1, Arg2);
   else if (sizeof(T) == 8)
       TORC8.Insert(ArgXor, Arg1, Arg2);
   HandleValueProfile(Idx);
 }
 
 } // namespace fuzzer
 
+#if LIBFUZZER_WINDOWS
+#define COVERAGE_WEAK(Name) __declspec(dllexport) Name##_impl
+#else
+#define COVERAGE_WEAK(Name) __attribute__((visibility("default"))) Name
+#endif
+
 extern "C" {
-__attribute__((visibility("default")))
-void __sanitizer_cov_trace_pc_guard(uint32_t *Guard) {
+void COVERAGE_WEAK(__sanitizer_cov_trace_pc_guard)(uint32_t *Guard) {
   uintptr_t PC = (uintptr_t)__builtin_return_address(0);
   fuzzer::TPC.HandleTrace(Guard, PC);
 }
 
-__attribute__((visibility("default")))
-void __sanitizer_cov_trace_pc_guard_init(uint32_t *Start, uint32_t *Stop) {
+void COVERAGE_WEAK(__sanitizer_cov_trace_pc_guard_init)(uint32_t *Start,
+                                                        uint32_t *Stop) {
   fuzzer::TPC.HandleInit(Start, Stop);
 }
 
-__attribute__((visibility("default")))
-void __sanitizer_cov_trace_pc_indir(uintptr_t Callee) {
+void COVERAGE_WEAK(__sanitizer_cov_trace_pc_indir)(uintptr_t Callee) {
   uintptr_t PC = (uintptr_t)__builtin_return_address(0);
   fuzzer::TPC.HandleCallerCallee(PC, Callee);
 }
 
-__attribute__((visibility("default")))
-void __sanitizer_cov_trace_cmp8(uint64_t Arg1, uint64_t Arg2) {
+void COVERAGE_WEAK(__sanitizer_cov_trace_cmp8)(uint64_t Arg1, uint64_t Arg2) {
   fuzzer::TPC.HandleCmp(__builtin_return_address(0), Arg1, Arg2);
 }
-__attribute__((visibility("default")))
-void __sanitizer_cov_trace_cmp4(uint32_t Arg1, uint32_t Arg2) {
+void COVERAGE_WEAK(__sanitizer_cov_trace_cmp4)(uint32_t Arg1, uint32_t Arg2) {
   fuzzer::TPC.HandleCmp(__builtin_return_address(0), Arg1, Arg2);
 }
-__attribute__((visibility("default")))
-void __sanitizer_cov_trace_cmp2(uint16_t Arg1, uint16_t Arg2) {
+void COVERAGE_WEAK(__sanitizer_cov_trace_cmp2)(uint16_t Arg1, uint16_t Arg2) {
   fuzzer::TPC.HandleCmp(__builtin_return_address(0), Arg1, Arg2);
 }
-__attribute__((visibility("default")))
-void __sanitizer_cov_trace_cmp1(uint8_t Arg1, uint8_t Arg2) {
+void COVERAGE_WEAK(__sanitizer_cov_trace_cmp1)(uint8_t Arg1, uint8_t Arg2) {
   fuzzer::TPC.HandleCmp(__builtin_return_address(0), Arg1, Arg2);
 }
 
-__attribute__((visibility("default")))
-void __sanitizer_cov_trace_switch(uint64_t Val, uint64_t *Cases) {
+void COVERAGE_WEAK(__sanitizer_cov_trace_switch)(uint64_t Val, uint64_t *Cases) {
   uint64_t N = Cases[0];
   uint64_t ValSizeInBits = Cases[1];
   uint64_t *Vals = Cases + 2;
   // Skip the most common and the most boring case.
   if (Vals[N - 1]  < 256 && Val < 256)
     return;
   char *PC = (char*)__builtin_return_address(0);
   size_t i;
   uint64_t Token = 0;
   for (i = 0; i < N; i++) {
     Token = Val ^ Vals[i];
     if (Val < Vals[i])
       break;
   }
 
   if (ValSizeInBits == 16)
     fuzzer::TPC.HandleCmp(PC + i, static_cast<uint16_t>(Token), (uint16_t)(0));
   else if (ValSizeInBits == 32)
     fuzzer::TPC.HandleCmp(PC + i, static_cast<uint32_t>(Token), (uint32_t)(0));
   else
     fuzzer::TPC.HandleCmp(PC + i, Token, (uint64_t)(0));
 }
 
-__attribute__((visibility("default")))
-void __sanitizer_cov_trace_div4(uint32_t Val) {
+void COVERAGE_WEAK(__sanitizer_cov_trace_div4)(uint32_t Val) {
   fuzzer::TPC.HandleCmp(__builtin_return_address(0), Val, (uint32_t)0);
 }
-__attribute__((visibility("default")))
-void __sanitizer_cov_trace_div8(uint64_t Val) {
+void COVERAGE_WEAK(__sanitizer_cov_trace_div8)(uint64_t Val) {
   fuzzer::TPC.HandleCmp(__builtin_return_address(0), Val, (uint64_t)0);
 }
-__attribute__((visibility("default")))
-void __sanitizer_cov_trace_gep(uintptr_t Idx) {
+void COVERAGE_WEAK(__sanitizer_cov_trace_gep)(uintptr_t Idx) {
   fuzzer::TPC.HandleCmp(__builtin_return_address(0), Idx, (uintptr_t)0);
 }
 
 }  // extern "C"