Lines Matching refs:Size
71 size_t MutationDispatcher::Mutate_Custom(uint8_t *Data, size_t Size,
73 return EF->LLVMFuzzerCustomMutator(Data, Size, MaxSize, Rand.Rand());
76 size_t MutationDispatcher::Mutate_CustomCrossOver(uint8_t *Data, size_t Size,
78 if (!Corpus || Corpus->size() < 2 || Size == 0)
87 Data, Size, Other.data(), Other.size(), U.data(), U.size(), Rand.Rand());
95 size_t MutationDispatcher::Mutate_ShuffleBytes(uint8_t *Data, size_t Size,
97 if (Size > MaxSize) return 0;
98 assert(Size);
100 Rand(std::min(Size, (size_t)8)) + 1; // [1,8] and <= Size.
101 size_t ShuffleStart = Rand(Size - ShuffleAmount);
102 assert(ShuffleStart + ShuffleAmount <= Size);
105 return Size;
108 size_t MutationDispatcher::Mutate_EraseBytes(uint8_t *Data, size_t Size,
110 assert(Size);
111 if (Size == 1) return 0;
112 size_t N = Rand(Size / 2) + 1;
113 assert(N < Size);
114 size_t Idx = Rand(Size - N + 1);
116 memmove(Data + Idx, Data + Idx + N, Size - Idx - N);
117 // Printf("Erase: %zd %zd => %zd; Idx %zd\n", N, Size, Size - N, Idx);
118 return Size - N;
121 size_t MutationDispatcher::Mutate_InsertByte(uint8_t *Data, size_t Size,
123 if (Size >= MaxSize) return 0;
124 size_t Idx = Rand(Size + 1);
126 memmove(Data + Idx + 1, Data + Idx, Size - Idx);
128 return Size + 1;
132 size_t Size,
135 if (Size + kMinBytesToInsert >= MaxSize) return 0;
136 size_t MaxBytesToInsert = std::min(MaxSize - Size, (size_t)128);
138 assert(Size + N <= MaxSize && N);
139 size_t Idx = Rand(Size + 1);
141 memmove(Data + Idx + N, Data + Idx, Size - Idx);
146 return Size + N;
149 size_t MutationDispatcher::Mutate_ChangeByte(uint8_t *Data, size_t Size,
151 if (Size > MaxSize) return 0;
152 size_t Idx = Rand(Size);
154 return Size;
157 size_t MutationDispatcher::Mutate_ChangeBit(uint8_t *Data, size_t Size,
159 if (Size > MaxSize) return 0;
160 size_t Idx = Rand(Size);
162 return Size;
166 size_t Size,
168 return AddWordFromDictionary(ManualDictionary, Data, Size, MaxSize);
172 uint8_t *Data, size_t Size, size_t MaxSize) {
173 return AddWordFromDictionary(TempAutoDictionary, Data, Size, MaxSize);
176 size_t MutationDispatcher::ApplyDictionaryEntry(uint8_t *Data, size_t Size,
181 DE.GetPositionHint() + W.size() < Size &&
184 if (Size + W.size() > MaxSize) return 0;
185 size_t Idx = UsePositionHint ? DE.GetPositionHint() : Rand(Size + 1);
186 memmove(Data + Idx + W.size(), Data + Idx, Size - Idx);
188 Size += W.size();
190 if (W.size() > Size) return 0;
191 size_t Idx = UsePositionHint ? DE.GetPositionHint() : Rand(Size - W.size());
194 return Size;
205 T Arg1, T Arg2, const uint8_t *Data, size_t Size) {
210 const uint8_t *End = Data + Size;
236 uint8_t *Data, size_t Size, size_t MaxSize) {
241 DE = MakeDictionaryEntryFromCMP(X.A, X.B, Data, Size);
246 Size);
248 DE = MakeDictionaryEntryFromCMP(X.A, X.B, Data, Size);
250 Size = ApplyDictionaryEntry(Data, Size, MaxSize, DE);
251 if (!Size) return 0;
257 return Size;
261 uint8_t *Data, size_t Size, size_t MaxSize) {
262 return AddWordFromDictionary(PersistentAutoDictionary, Data, Size, MaxSize);
266 size_t Size, size_t MaxSize) {
267 if (Size > MaxSize) return 0;
270 Size = ApplyDictionaryEntry(Data, Size, MaxSize, DE);
271 if (!Size) return 0;
274 return Size;
318 size_t MutationDispatcher::Mutate_CopyPart(uint8_t *Data, size_t Size,
320 if (Size > MaxSize) return 0;
322 return CopyPartOf(Data, Size, Data, Size);
324 return InsertPartOf(Data, Size, Data, Size, MaxSize);
327 size_t MutationDispatcher::Mutate_ChangeASCIIInteger(uint8_t *Data, size_t Size,
329 if (Size > MaxSize) return 0;
330 size_t B = Rand(Size);
331 while (B < Size && !isdigit(Data[B])) B++;
332 if (B == Size) return 0;
334 while (E < Size && isdigit(Data[E])) E++;
358 return Size;
362 size_t ChangeBinaryInteger(uint8_t *Data, size_t Size, Random &Rand) {
363 if (Size < sizeof(T)) return 0;
364 size_t Off = Rand(Size - sizeof(T) + 1);
365 assert(Off + sizeof(T) <= Size);
368 Val = Size;
383 return Size;
387 size_t Size,
389 if (Size > MaxSize) return 0;
391 case 3: return ChangeBinaryInteger<uint64_t>(Data, Size, Rand);
392 case 2: return ChangeBinaryInteger<uint32_t>(Data, Size, Rand);
393 case 1: return ChangeBinaryInteger<uint16_t>(Data, Size, Rand);
394 case 0: return ChangeBinaryInteger<uint8_t>(Data, Size, Rand);
400 size_t MutationDispatcher::Mutate_CrossOver(uint8_t *Data, size_t Size,
402 if (Size > MaxSize) return 0;
403 if (!Corpus || Corpus->size() < 2 || Size == 0) return 0;
412 NewSize = CrossOver(Data, Size, O.data(), O.size(), U.data(), U.size());
474 size_t MutationDispatcher::Mutate(uint8_t *Data, size_t Size, size_t MaxSize) {
475 return MutateImpl(Data, Size, MaxSize, Mutators);
478 size_t MutationDispatcher::DefaultMutate(uint8_t *Data, size_t Size,
480 return MutateImpl(Data, Size, MaxSize, DefaultMutators);
484 size_t MutationDispatcher::MutateImpl(uint8_t *Data, size_t Size,
488 if (Size == 0) {
495 assert(Size > 0);
496 // Some mutations may fail (e.g. can't insert more bytes if Size == MaxSize),
501 size_t NewSize = (this->*(M.Fn))(Data, Size, MaxSize);
509 return std::min(Size, MaxSize);