<div dir="ltr">For starters, the proposed text is a non-starter (forgive the play on words)<div>because there is no Chapter 2 Section 4 in Knuth's The Art of Computer</div><div>Programming Volume 1. Chapter 2 is entitled Information Structures, in which</div><div>section 2.4 (is that what you mean by "Section 4"?) is entitled Multilinked</div><div>Structures, and has nothing to do with the modulo operation.</div><div><br></div><div>The discussion mentions Section 1.2.4, which is actually in Volume 1,</div><div>Chapter 1, is entitled Integer Functions and Elementary Number Theory,</div><div>and does define and discuss the modulo operation.</div><div><br></div><div>Even if the citation were correct, I would object on the grounds that I believe</div><div>the DWARF text should provide the definition, not a citation that the reader</div><div>needs to consult. A footnote to an external source might be OK if there were</div><div>complicated issues of possible supplementary interest.</div><div><br></div><div>Finally, the Knuth definition is given in terms of real numbers, of which</div><div>integers are a special case, using floor and ceiling operations. This </div><div>would be appropriate if DWARF DW_OP_mod were intended to apply</div><div>to floating-point operands but is rather pedantic overkill for just integers.</div><div><br></div><div>But I think the real problem is not the definition of DW_OP_mod per se but</div><div>the definition of the generic type. DWARF Section 2.5.2 defines the generic</div><div>type as an "integral type that has the size of an address on the target machine</div><div>and unspecified signedness." We know that some architectures treat addresses</div><div>as signed and some as unsigned integers, and DWARF is trying not to care.</div><div><br></div><div>Most of the time it mostly doesn't matter. But to be concrete, what does one make of</div><div><br></div><div> DW_OP_lit5</div><div> DW_OP_lit2</div><div> DW_OP_neg</div><div> DW_OP_mod</div><div><br></div><div>If the generic type is signed, then the result is -1. However, if the generic type</div><div>is thought to be unsigned, then "-2" is just a very large positive number and</div><div>the result is 5.</div><div><br></div><div>We might think about solving this problem by defining the generic type to be</div><div> a) signed</div><div> b) unsigned</div><div> c) signedness implementation-defined</div><div>I would not advocate either a) or b). Moreover, I would be very caution in overturning the</div><div>"non-signedness" of generic type which has been characteristic of DWARF from the beginning</div><div>(even before the name "generic type" was introduced).</div><div><br></div><div>Defining DW_OP_mod to be defined only for unsigned integers seems</div><div>overkill and unnecessary when no generic type operands are involved.</div><div><br></div><div>A more permissive approach is to specify that an operand of the generic</div><div>type is implicitly treated as unsigned. Then use the Knuth definition restricted to</div><div>integers. This is close to Ben's second alternative but further resolves the ambiguity</div><div>of generic signedness.</div><div><br></div><div>Ben has raised a definite problem for which further thought is surely warranted...</div><div><br></div><div>Ron</div><div><br></div><div><br></div><div><br></div><div><br></div><div><br></div></div><br><div class="gmail_quote gmail_quote_container"><div dir="ltr" class="gmail_attr">On Wed, Sep 24, 2025 at 2:32 PM Ben Woodard via Dwarf-discuss <<a href="mailto:dwarf-discuss@lists.dwarfstd.org">dwarf-discuss@lists.dwarfstd.org</a>> wrote:<br></div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex">Background:<br>
<br>
Evidently, originally DWARF didn't allow arithmetic operations on <br>
floating point numbers and most uses of the DWARF stack were done with <br>
the assumption that the values being acted upon were addresses and so <br>
the computation was assumed to be acting upon unsigned numbers.<br>
<br>
At some point, DWARF began to allow the arithmetic operations to work on <br>
floating point numbers and several operations were explicitly defined to <br>
work over non-integral values. This led to the paragraph in the current <br>
DWARF working draft that says in section 2.5.2.4 on page 37 lines 24-27:<br>
<br>
"Operations other than DW_OP_abs, DW_OP_div, DW_OP_minus,<br>
DW_OP_mul, DW_OP_neg and DW_OP_plus require integral types of the<br>
operand (either integral base type or the generic type). Operations do <br>
not cause<br>
an exception on overflow."<br>
<br>
Unlike all the other arithmetic operations this explicitly limits <br>
DW_OP_mod to integral base types and the generic type. It lumps <br>
DW_OP_mod in with the logical operations. Furthermore, there are <br>
multiple definitions of the modulo operator which vary in how they <br>
handle signed values.<br>
<br>
According to the dwarf-discuss archives, this issue came up back in 2011 <br>
and at that time Michael Eager made a pronouncement that DW_OP_mod used <br>
the modulo algorithm for unsigned arithmetic. However, this decision was <br>
not recorded in the standard. Since that time, consumers have <br>
implemented different implementations of DW_OP_mod.<br>
<br>
This proposal seeks to clarify and harmonize the consumer <br>
implementations of the DW_OP_mod operator by defining which algorithm to <br>
use for signed arithmetic as well as define it for floating point numbers.<br>
<br>
Proposal:<br>
<br>
Add DW_OP_mod to the list of operators which do not require integral <br>
base types by changing:<br>
<br>
Operations other than DW_OP_abs, DW_OP_div, DW_OP_minus, DW_OP_mul, <br>
DW_OP_neg and DW_OP_plus require integral types of the operand (either <br>
integral base type or the generic type).<br>
<br>
To:<br>
<br>
Operations other than DW_OP_abs, DW_OP_div, DW_OP_mod, DW_OP_minus, <br>
DW_OP_mul, DW_OP_neg and DW_OP_plus require integral types of the <br>
operand (either integral base type or the generic type).<br>
<br>
Then append the following sentence to the description of the DW_OP_mod:<br>
<br>
The algorithm used to implement modulo shall be the one defined in The <br>
Art of Computer Programming Volume 1: Fundamental Algorithms Chapter 2 <br>
Section 4. Knuth.<br>
<br>
Alternative proposals:<br>
<br>
1) Explicitly state in the standard that DW_OP_mod is only defined for <br>
unsigned integral arithmetic. This effectively standardizes the Michael <br>
Eager's pronouncement from 2011.<br>
<br>
2) Pick any algorithm for modulo that works for signed as well unsigned <br>
arithmetic and specify that DW_OP_modulo shall follow it. The current <br>
GDB implementation follows Knuth 1.2.4 for signed and unsigned integral <br>
arithmetic but excludes the algorithm for reals and floating point numbers.<br>
<br>
<br>
-- <br>
Dwarf-discuss mailing list<br>
<a href="mailto:Dwarf-discuss@lists.dwarfstd.org" target="_blank">Dwarf-discuss@lists.dwarfstd.org</a><br>
<a href="https://lists.dwarfstd.org/mailman/listinfo/dwarf-discuss" rel="noreferrer" target="_blank">https://lists.dwarfstd.org/mailman/listinfo/dwarf-discuss</a><br>
</blockquote></div>