Content-Type: multipart/mixed; boundary="------------xfhMmudaQIXKeySVLl8ODE88"
Message-ID: <f6b7eaf0-0bda-414d-962f-84c30713e390@gmail.com>
Date: Sat, 1 Nov 2025 23:24:45 -0600
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
Subject: Re: [PATCH] Add Windows support for backtrace_functions (MSVC only)
To: Euler Taveira <euler@eulerto.com>,
 Jakub Wartak <jakub.wartak@enterprisedb.com>
Cc: =?UTF-8?Q?=C3=81lvaro_Herrera?= <alvherre@kurilemu.de>,
 Michael Paquier <michael@paquier.xyz>,
 pgsql-hackers <pgsql-hackers@postgresql.org>
References: <202510300932.isdvgkzqzshk@alvherre.pgsql>
 <5b4c6ce0-ed17-4abb-9127-859cc95cbdf3@gmail.com>
 <CAKZiRmzuqPmgd_A+M+RiuT-4UtDt_TASqQJoqCdvCUrVY3w7cg@mail.gmail.com>
 <30aea073-109c-43cc-979c-081b922d055d@gmail.com>
 <2241662b-da7d-428f-beba-a416ef48e9e9@app.fastmail.com>
 <c04e5ca9-d1e1-48a6-acf3-0fd42f103ac0@gmail.com>
 <31f43d88-9949-48c5-9497-b9a9b7cdee2b@gmail.com>
 <cbca062e-98df-4f07-b8ae-f757c1ee89d7@app.fastmail.com>
Content-Language: en-US
From: Bryan Green <dbryan.green@gmail.com>
In-Reply-To: <cbca062e-98df-4f07-b8ae-f757c1ee89d7@app.fastmail.com>
Archived-At: 
 <https://www.postgresql.org/message-id/f6b7eaf0-0bda-414d-962f-84c30713e390%40gmail.com>
Precedence: bulk

This is a multi-part message in MIME format.
--------------xfhMmudaQIXKeySVLl8ODE88
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit

On 11/1/2025 9:31 AM, Euler Taveira wrote:
> On Sat, Nov 1, 2025, at 1:40 AM, Bryan Green wrote:
>> v5 patch attached, incorporating all of Euler's feedback with a caveat
>> around unicode.
>>
> 
> Thanks for sharing another patch.
>

Thanks for the continued review.  v6 patch attached with your latest 
suggestions incorporated.

>> The most interesting aspect turned out to be the encoding conversion for
>> symbol names and file paths. Initially I tried using the generic
>> SYMBOL_INFO and SymFromAddr functions as Euler suggested, but ran into a
>> subtle issue: on PostgreSQL's Windows builds, these become SYMBOL_INFOA
>> and SymFromAddrA (the ANSI versions), which return strings in whatever
>> Windows ANSI codepage happens to be active (CP1252, etc). This doesn't
>> necessarily match the database encoding.
>>
> 
> Odd. Does the build define UNICODE? (Don't have a Windows machine right now to
> explore this case.)
>

PostgreSQL's Windows builds don't define UNICODE globally. I verified 
this by checking that SYMBOL_INFO resolves to the ANSI version - when I 
tried using it with wchar2char(), the conversion failed because the 
input wasn't actually wide characters.
>> The solution was to use the explicit Unicode versions (SYMBOL_INFOW and
>> SymFromAddrW), which reliably return UTF-16 strings that wchar2char()
>> can properly convert to the database encoding. This handles both UTF-8
>> and non-UTF-8 databases correctly, and wchar2char() gracefully returns
>> -1 on conversion failure rather than throwing errors during error
>> handling. Of course this also necessitated using IMAGEHLP_LINEW64 and
>> SymGetLineFromAddrW64.
>>
> 
> Works for me.
> 
>> This patch also adds a check for zero frames returned by backtrace() on
>> Unix/Linux platforms, which can occur in certain circumstances such as
>> ARM builds without unwind tables.
>>
> 
> Please create a separate patch.

Removed the check - I'll submit that separately.

> 
> +					if (result != (size_t) -1)
> +					{
> +						appendStringInfo(&errtrace,
> +										 "\n%s+0x%llx [0x%llx] [%s:%lu]",
> +										 symbol_name,
> +										 (unsigned long long) displacement,
> +										 (unsigned long long) address,
> +										 filename,
> +										 (unsigned long) line.LineNumber);
> +					}
> +					else
> +					{
> +						/* Filename conversion failed, omit it */
> +						appendStringInfo(&errtrace,
> +										 "\n%s+0x%llx [0x%llx]",
> +										 symbol_name,
> +										 (unsigned long long) displacement,
> +										 (unsigned long long) address);
> +					}
> +				}
> +				else
> +				{
> +					/* No line info available */
> +					appendStringInfo(&errtrace,
> +									 "\n%s+0x%llx [0x%llx]",
> +									 symbol_name,
> +									 (unsigned long long) displacement,
> +									 (unsigned long long) address);
> +				}
> 
> One last suggestion is to have a single code path for these last two conditions
> to avoid duplication. Move this if to outside the "if SymGetLineFromAddrW64".
> Merge the comment to reflect both conditions (file conversion failed and no
> line info).
> 
> 

Done. Now the code prints symbol+offset+address first, then 
conditionally appends line info if both SymGetLineFromAddrW64 succeeds 
and the filename conversion succeeds. This eliminates the duplication.

Also added the backtrace_cleanup() function per Jakub's request to 
properly release DbgHelp resources via SymCleanup() on process exit. 
This inadvertently was removed when the TAP tests were removed.

Tested with both debug and release builds. With PDB files present, 
backtraces now show symbol names, offsets, addresses, filenames, and 
line numbers. Without PDB files (release build), exported function names 
are still resolved.

Bryan
--------------xfhMmudaQIXKeySVLl8ODE88
Content-Type: text/plain; charset=UTF-8;
 name="v6-0001-Add-backtrace-support-for-Windows-using-DbgHelp-A.patch"
Content-Disposition: attachment;
 filename*0="v6-0001-Add-backtrace-support-for-Windows-using-DbgHelp-A.pa";
 filename*1="tch"
Content-Transfer-Encoding: base64
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--------------xfhMmudaQIXKeySVLl8ODE88--