Cross Reference: /src/sys/external/bsd/compiler_rt/dist/lib/fuzzer/FuzzerMutate.cpp

Lines Matching refs:Data
24   PrintASCII(W.data(), W.size(), PrintAfter);
69 size_t MutationDispatcher::Mutate_Custom(uint8_t *Data, size_t Size,
71   return EF->LLVMFuzzerCustomMutator(Data, Size, MaxSize, Rand.Rand());
74 size_t MutationDispatcher::Mutate_CustomCrossOver(uint8_t *Data, size_t Size,
85       Data, Size, Other.data(), Other.size(), U.data(), U.size(), Rand.Rand());
89   memcpy(Data, U.data(), NewSize);
93 size_t MutationDispatcher::Mutate_ShuffleBytes(uint8_t *Data, size_t Size,
100   std::shuffle(Data + ShuffleStart, Data + ShuffleStart + ShuffleAmount, Rand);
104 size_t MutationDispatcher::Mutate_EraseBytes(uint8_t *Data, size_t Size,
110   // Erase Data[Idx:Idx+N].
111   memmove(Data + Idx, Data + Idx + N, Size - Idx - N);
116 size_t MutationDispatcher::Mutate_InsertByte(uint8_t *Data, size_t Size,
120   // Insert new value at Data[Idx].
121   memmove(Data + Idx + 1, Data + Idx, Size - Idx);
122   Data[Idx] = RandCh(Rand);
126 size_t MutationDispatcher::Mutate_InsertRepeatedBytes(uint8_t *Data,
135   // Insert new values at Data[Idx].
136   memmove(Data + Idx + N, Data + Idx, Size - Idx);
140     Data[Idx + i] = Byte;
144 size_t MutationDispatcher::Mutate_ChangeByte(uint8_t *Data, size_t Size,
148   Data[Idx] = RandCh(Rand);
152 size_t MutationDispatcher::Mutate_ChangeBit(uint8_t *Data, size_t Size,
156   Data[Idx] ^= 1 << Rand(8);
160 size_t MutationDispatcher::Mutate_AddWordFromManualDictionary(uint8_t *Data,
163   return AddWordFromDictionary(ManualDictionary, Data, Size, MaxSize);
166 size_t MutationDispatcher::ApplyDictionaryEntry(uint8_t *Data, size_t Size,
176     memmove(Data + Idx + W.size(), Data + Idx, Size - Idx);
177     memcpy(Data + Idx, W.data(), W.size());
182     memcpy(Data + Idx, W.data(), W.size());
196     size_t ArgSize, const uint8_t *Data,
201   const uint8_t *End = Data + Size;
210     for (const uint8_t *Cur = Data;
215       Positions[NumPositions++] = Cur - Data;
227     T Arg1, T Arg2, const uint8_t *Data, size_t Size) {
233                                     sizeof(Arg1), Data, Size);
237     const Word &Arg1, const Word &Arg2, const uint8_t *Data, size_t Size) {
238   return MakeDictionaryEntryFromCMP(Arg1.data(), Arg2.data(), Arg1.data(),
239                                     Arg2.data(), Arg1.size(), Data, Size);
243     uint8_t *Data, size_t Size, size_t MaxSize) {
249     DE = MakeDictionaryEntryFromCMP(X.A, X.B, Data, Size);
254       DE = MakeDictionaryEntryFromCMP((uint16_t)X.A, (uint16_t)X.B, Data, Size);
256       DE = MakeDictionaryEntryFromCMP(X.A, X.B, Data, Size);
260     DE = MakeDictionaryEntryFromCMP(X.A, X.B, Data, Size);
270   Size = ApplyDictionaryEntry(Data, Size, MaxSize, DE);
281     uint8_t *Data, size_t Size, size_t MaxSize) {
282   return AddWordFromDictionary(PersistentAutoDictionary, Data, Size, MaxSize);
285 size_t MutationDispatcher::AddWordFromDictionary(Dictionary &D, uint8_t *Data,
290   Size = ApplyDictionaryEntry(Data, Size, MaxSize, DE);
328     memcpy(MutateInPlaceHere.data(), From + FromBeg, CopySize);
330     memmove(To + ToInsertPos, MutateInPlaceHere.data(), CopySize);
338 size_t MutationDispatcher::Mutate_CopyPart(uint8_t *Data, size_t Size,
344     return CopyPartOf(Data, Size, Data, Size);
346     return InsertPartOf(Data, Size, Data, Size, MaxSize);
349 size_t MutationDispatcher::Mutate_ChangeASCIIInteger(uint8_t *Data, size_t Size,
353   while (B < Size && !isdigit(Data[B])) B++;
356   while (E < Size && isdigit(Data[E])) E++;
359   // strtol and friends don't accept non-zero-teminated data, parse it manually.
360   uint64_t Val = Data[B] - '0';
362     Val = Val * 10 + Data[i] - '0';
377     Data[Idx] = (Val % 10) + '0';
384 size_t ChangeBinaryInteger(uint8_t *Data, size_t Size, Random &Rand) {
394     memcpy(&Val, Data + Off, sizeof(Val));
404   memcpy(Data + Off, &Val, sizeof(Val));
408 size_t MutationDispatcher::Mutate_ChangeBinaryInteger(uint8_t *Data,
413     case 3: return ChangeBinaryInteger<uint64_t>(Data, Size, Rand);
414     case 2: return ChangeBinaryInteger<uint32_t>(Data, Size, Rand);
415     case 1: return ChangeBinaryInteger<uint16_t>(Data, Size, Rand);
416     case 0: return ChangeBinaryInteger<uint8_t>(Data, Size, Rand);
422 size_t MutationDispatcher::Mutate_CrossOver(uint8_t *Data, size_t Size,
434       NewSize = CrossOver(Data, Size, O.data(), O.size(), U.data(), U.size());
437       NewSize = InsertPartOf(O.data(), O.size(), U.data
439         NewSize = CopyPartOf(O.data(), O.size(), U.data(), U.size());
442       NewSize = CopyPartOf(O.data(), O.size(), U.data(), U.size());
448   memcpy(Data, U.data(), NewSize);
498 size_t MutationDispatcher::Mutate(uint8_t *Data, size_t Size, size_t MaxSize) {
499   return MutateImpl(Data, Size, MaxSize, Mutators);
502 size_t MutationDispatcher::DefaultMutate(uint8_t *Data, size_t Size,
504   return MutateImpl(Data, Size, MaxSize, DefaultMutators);
507 // Mutates Data in place, returns new size.
508 size_t MutationDispatcher::MutateImpl(uint8_t *Data, size_t Size,
514   // Try several times before returning un-mutated data.
517     size_t NewSize = (this->*(M.Fn))(Data, Size, MaxSize);
520         ToASCII(Data, NewSize);
525   *Data = ' ';
529 // Mask represents the set of Data bytes that are worth mutating.
530 size_t MutationDispatcher::MutateWithMask(uint8_t *Data, size_t Size,
544       T[OneBits++] = Data[I];
547   size_t NewSize = Mutate(T.data(), OneBits, OneBits);
553       Data[I] = T[J++];
OpenGrok
