bpo-36389: Fix _PyBytesWriter in release mode (GH-16624) · python/cpython@60ec6ef (original) (raw)

`@@ -2031,20 +2031,6 @@ _Py_GetAllocatedBlocks(void)

2031

` * it wraps a real allocator, adding extra debugging info to the memory blocks.

2032

` */

2033

2034

/* Special bytes broadcast into debug memory blocks at appropriate times.

2035

Strings of these are unlikely to be valid addresses, floats, ints or

2036

7-bit ASCII. If modified, _PyMem_IsPtrFreed() should be updated as well.

2037

2038

Byte patterns 0xCB, 0xBB and 0xFB have been replaced with 0xCD, 0xDD and

2039

0xFD to use the same values than Windows CRT debug malloc() and free().

2040

2041

#undef CLEANBYTE

2042

#undef DEADBYTE

2043

#undef FORBIDDENBYTE

2044

#define CLEANBYTE 0xCD /* clean (newly allocated) memory */

2045

#define DEADBYTE 0xDD /* dead (newly freed) memory */

2046

#define FORBIDDENBYTE 0xFD /* untouchable bytes at each end of a block */

2047

-

2048

2034

`/* Uncomment this define to add the "serialno" field */

2049

2035

`/* #define PYMEM_DEBUG_SERIALNO */

2050

2036

`@@ -2106,14 +2092,14 @@ p[0: S]

2106

2092

`p[S]

2107

2093

` API ID. See PEP 445. This is a character, but seems undocumented.

2108

2094

`p[S+1: 2*S]

2109

Copies of FORBIDDENBYTE. Used to catch under- writes and reads.

2095

Copies of PYMEM_FORBIDDENBYTE. Used to catch under- writes and reads.

2110

2096

`p[2S: 2S+n]

2111

The requested memory, filled with copies of CLEANBYTE.

2097

The requested memory, filled with copies of PYMEM_CLEANBYTE.

2112

2098

` Used to catch reference to uninitialized memory.

2113

2099

` &p[2*S] is returned. Note that this is 8-byte aligned if pymalloc

2114

2100

` handled the request itself.

2115

2101

`p[2S+n: 2S+n+S]

2116

Copies of FORBIDDENBYTE. Used to catch over- writes and reads.

2102

Copies of PYMEM_FORBIDDENBYTE. Used to catch over- writes and reads.

2117

2103

`p[2S+n+S: 2S+n+2*S]

2118

2104

` A serial number, incremented by 1 on each call to _PyMem_DebugMalloc

2119

2105

` and _PyMem_DebugRealloc.

`@@ -2170,15 +2156,15 @@ _PyMem_DebugRawAlloc(int use_calloc, void *ctx, size_t nbytes)

2170

2156

`/* at p, write size (SST bytes), id (1 byte), pad (SST-1 bytes) */

2171

2157

`write_size_t(p, nbytes);

2172

2158

`p[SST] = (uint8_t)api->api_id;

2173

memset(p + SST + 1, FORBIDDENBYTE, SST-1);

2159

memset(p + SST + 1, PYMEM_FORBIDDENBYTE, SST-1);

2174

2160

2175

2161

`if (nbytes > 0 && !use_calloc) {

2176

memset(data, CLEANBYTE, nbytes);

2162

memset(data, PYMEM_CLEANBYTE, nbytes);

2177

2163

` }

2178

2164

2179

2165

`/* at tail, write pad (SST bytes) and serialno (SST bytes) */

2180

2166

`tail = data + nbytes;

2181

memset(tail, FORBIDDENBYTE, SST);

2167

memset(tail, PYMEM_FORBIDDENBYTE, SST);

2182

2168

`#ifdef PYMEM_DEBUG_SERIALNO

2183

2169

`write_size_t(tail + SST, serialno);

2184

2170

`#endif

`@@ -2204,7 +2190,7 @@ _PyMem_DebugRawCalloc(void *ctx, size_t nelem, size_t elsize)

2204

2190

2205

2191

`/* The debug free first checks the 2*SST bytes on each end for sanity (in

2206

2192

` particular, that the FORBIDDENBYTEs with the api ID are still intact).

2207

Then fills the original bytes with DEADBYTE.

2193

Then fills the original bytes with PYMEM_DEADBYTE.

2208

2194

` Then calls the underlying free.

2209

2195

`*/

2210

2196

`static void

`@@ -2222,7 +2208,7 @@ _PyMem_DebugRawFree(void *ctx, void *p)

2222

2208

`_PyMem_DebugCheckAddress(api->api_id, p);

2223

2209

`nbytes = read_size_t(q);

2224

2210

`nbytes += PYMEM_DEBUG_EXTRA_BYTES;

2225

memset(q, DEADBYTE, nbytes);

2211

memset(q, PYMEM_DEADBYTE, nbytes);

2226

2212

`api->alloc.free(api->alloc.ctx, q);

2227

2213

2228

2214

`@@ -2264,14 +2250,14 @@ _PyMem_DebugRawRealloc(void *ctx, void *p, size_t nbytes)

2264

2250

` */

2265

2251

`if (original_nbytes <= sizeof(save)) {

2266

2252

`memcpy(save, data, original_nbytes);

2267

memset(data - 2 * SST, DEADBYTE,

2253

memset(data - 2 * SST, PYMEM_DEADBYTE,

2268

2254

`original_nbytes + PYMEM_DEBUG_EXTRA_BYTES);

2269

2255

` }

2270

2256

`else {

2271

2257

`memcpy(save, data, ERASED_SIZE);

2272

memset(head, DEADBYTE, ERASED_SIZE + 2 * SST);

2258

memset(head, PYMEM_DEADBYTE, ERASED_SIZE + 2 * SST);

2273

2259

`memcpy(&save[ERASED_SIZE], tail - ERASED_SIZE, ERASED_SIZE);

2274

memset(tail - ERASED_SIZE, DEADBYTE,

2260

memset(tail - ERASED_SIZE, PYMEM_DEADBYTE,

2275

2261

`ERASED_SIZE + PYMEM_DEBUG_EXTRA_BYTES - 2 * SST);

2276

2262

` }

2277

2263

`@@ -2293,10 +2279,10 @@ _PyMem_DebugRawRealloc(void *ctx, void *p, size_t nbytes)

2293

2279

2294

2280

`write_size_t(head, nbytes);

2295

2281

`head[SST] = (uint8_t)api->api_id;

2296

memset(head + SST + 1, FORBIDDENBYTE, SST-1);

2282

memset(head + SST + 1, PYMEM_FORBIDDENBYTE, SST-1);

2297

2283

2298

2284

`tail = data + nbytes;

2299

memset(tail, FORBIDDENBYTE, SST);

2285

memset(tail, PYMEM_FORBIDDENBYTE, SST);

2300

2286

`#ifdef PYMEM_DEBUG_SERIALNO

2301

2287

`write_size_t(tail + SST, block_serialno);

2302

2288

`#endif

`@@ -2320,7 +2306,8 @@ _PyMem_DebugRawRealloc(void *ctx, void *p, size_t nbytes)

2320

2306

2321

2307

`if (nbytes > original_nbytes) {

2322

2308

`/* growing: mark new extra memory clean */

2323

memset(data + original_nbytes, CLEANBYTE, nbytes - original_nbytes);

2309

memset(data + original_nbytes, PYMEM_CLEANBYTE,

2310

nbytes - original_nbytes);

2324

2311

` }

2325

2312

2326

2313

`return data;

`@@ -2399,7 +2386,7 @@ _PyMem_DebugCheckAddress(char api, const void *p)

2399

2386

` * the tail could lead to a segfault then.

2400

2387

` */

2401

2388

`for (i = SST-1; i >= 1; --i) {

2402

if (*(q-i) != FORBIDDENBYTE) {

2389

if (*(q-i) != PYMEM_FORBIDDENBYTE) {

2403

2390

`msg = "bad leading pad byte";

2404

2391

` goto error;

2405

2392

` }

`@@ -2408,7 +2395,7 @@ _PyMem_DebugCheckAddress(char api, const void *p)

2408

2395

`nbytes = read_size_t(q - 2*SST);

2409

2396

`tail = q + nbytes;

2410

2397

`for (i = 0; i < SST; ++i) {

2411

if (tail[i] != FORBIDDENBYTE) {

2398

if (tail[i] != PYMEM_FORBIDDENBYTE) {

2412

2399

`msg = "bad trailing pad byte";

2413

2400

` goto error;

2414

2401

` }

`@@ -2448,7 +2435,7 @@ _PyObject_DebugDumpAddress(const void *p)

2448

2435

`fprintf(stderr, " The %d pad bytes at p-%d are ", SST-1, SST-1);

2449

2436

`ok = 1;

2450

2437

`for (i = 1; i <= SST-1; ++i) {

2451

if (*(q-i) != FORBIDDENBYTE) {

2438

if (*(q-i) != PYMEM_FORBIDDENBYTE) {

2452

2439

`ok = 0;

2453

2440

`break;

2454

2441

` }

`@@ -2457,11 +2444,11 @@ _PyObject_DebugDumpAddress(const void *p)

2457

2444

`fputs("FORBIDDENBYTE, as expected.\n", stderr);

2458

2445

`else {

2459

2446

`fprintf(stderr, "not all FORBIDDENBYTE (0x%02x):\n",

2460

FORBIDDENBYTE);

2447

PYMEM_FORBIDDENBYTE);

2461

2448

`for (i = SST-1; i >= 1; --i) {

2462

2449

`const uint8_t byte = *(q-i);

2463

2450

`fprintf(stderr, " at p-%d: 0x%02x", i, byte);

2464

if (byte != FORBIDDENBYTE)

2451

if (byte != PYMEM_FORBIDDENBYTE)

2465

2452

`fputs(" *** OUCH", stderr);

2466

2453

`fputc('\n', stderr);

2467

2454

` }

`@@ -2476,7 +2463,7 @@ _PyObject_DebugDumpAddress(const void *p)

2476

2463

`fprintf(stderr, " The %d pad bytes at tail=%p are ", SST, (void *)tail);

2477

2464

`ok = 1;

2478

2465

`for (i = 0; i < SST; ++i) {

2479

if (tail[i] != FORBIDDENBYTE) {

2466

if (tail[i] != PYMEM_FORBIDDENBYTE) {

2480

2467

`ok = 0;

2481

2468

`break;

2482

2469

` }

`@@ -2485,12 +2472,12 @@ _PyObject_DebugDumpAddress(const void *p)

2485

2472

`fputs("FORBIDDENBYTE, as expected.\n", stderr);

2486

2473

`else {

2487

2474

`fprintf(stderr, "not all FORBIDDENBYTE (0x%02x):\n",

2488

FORBIDDENBYTE);

2475

PYMEM_FORBIDDENBYTE);

2489

2476

`for (i = 0; i < SST; ++i) {

2490

2477

`const uint8_t byte = tail[i];

2491

2478

`fprintf(stderr, " at tail+%d: 0x%02x",

2492

2479

`i, byte);

2493

if (byte != FORBIDDENBYTE)

2480

if (byte != PYMEM_FORBIDDENBYTE)

2494

2481

`fputs(" *** OUCH", stderr);

2495

2482

`fputc('\n', stderr);

2496

2483

` }