Add source assignment in symbol nodes #679

parth-07 · 2025-12-29T18:35:05Z

This commit changes how symbol expression nodes gets evaluated for the absolute symbols. The key goal is to improve the layout convergence when forward references is involved. This design change is a step in the direction to improve the layout convergence.

When the linker script contains forward references, then we may need to re-evaluate the linker script and the layout multiple times to reach convergence. For example:

SECTIONS {
  u = bar_end; // A1
  .foo (u) : { *(.text.foo) }
  v = w; // A2
  .bar (v) : { *(.text.bar) }
  bar_end = .; // A3
  w = 0x2000; // A4
}

The above linker script contains 4 assignments: A1, A2, A3, and A4, and it needs more than one pass of layout evaluation for reaching convergence. In the 1st pass, the assignment A1 is evaluted incorrectly because bar_end has not been assigned a value yet.

We also need to stop the layout pass in between and recompute the layout from the beginning whenever some initial assumption changes such as a new segment needs to be inserted.

There is an important difference between these two types of layout recomputation. In the first type, that is, layout recomputation to achieve layout convergence, we must use the symbol values from the previous pass.

In the second type, that is, layout recomputation due to an initial assumption change such as a new segment needs to be inserted, we must reset the symbol values before recomputing the layout. Let's see why:

SECTIONS {
  u = v; // A1
  .foo : { *(.text.foo) }
  v = 0x1000; // A2
  .data : { *(.text.data) }}
  v = 0x2000; // A3
}

In the first evaluation of A1, u is assigned the value 0. On encountering '.data' output section, the layout is recomputed, and this time when A1 is recomputed, u is assigned the value 0x1000 because A2 was evaluated in the last pass. The value 0x1000 is incorrect for u because the value of v that is to be used in A1 must come from the last evaluation of v, that is, A3. Reusing values from the last pass in this case is error-prone and can lead to incorrect layouts.

It is difficult to add logic for when to reuse symbol values and when to reset them because these two types of layout recomputations can be intermixed.

Adding a source assignment node with the symbol expression node makes the recomputation simpler by obviating the need to reset the symbol values in both the cases. The key idea is that the value of a symbol node of an absolute symbol is not the value of the corresponding symbol, but instead is the result of the last assignment node for that symbol.

Adding the source assignment with a symbol node has additional benefits as well:

It makes it easier to determine the culprit / closest assignment to
use in diagnostics when a symbol value is not converging.
It makes it easier to add heuristics such as constant expression
evaluation to speed up the layout convergence. For example:

u = v;
.foo (u) : { *(.text.foo) }
v = 0x2000;

In this case, if the symbol v encodes the source assignment, then we
can easily add heuristic to determine if v source assignment can be
evaluated early.

Selectively recompute only those assignment nodes which needs to be recomputed.
If we reset symbol values, then all the assignment nodes always needs
to be recomputed in each layout pass.

Resolves #468

This commit changes how symbol expression nodes gets evaluated for the absolute symbols. The key goal is to improve the layout convergence when forward references is involved. This design change is a step in the direction to improve the layout convergence. When the linker script contains forward references, then we may need to re-evaluate the linker script and the layout multiple times to reach convergence. For example: ``` SECTIONS { u = bar_end; // A1 .foo (u) : { *(.text.foo) } v = w; // A2 .bar (v) : { *(.text.bar) } bar_end = .; // A3 w = 0x2000; // A4 } ``` The above linker script contains 4 assignments: A1, A2, A3, and A4, and it needs more than one pass of layout evaluation for reaching convergence. In the 1st pass, the assignment A1 is evaluted incorrectly because `bar_end` has not been assigned a value yet. We also need to stop the layout pass in between and recompute the layout from the beginning whenever some initial assumption changes such as a new segment needs to be inserted. There is an important difference between these two types of layout recomputation. In the first type, that is, layout recomputation to achieve layout convergence, we must use the symbol values from the previous pass. In the second type, that is, layout recomputation due to an initial assumption change such as a new segment needs to be inserted, we must reset the symbol values before recomputing the layout. Let's see why: ``` SECTIONS { u = v; // A1 .foo : { *(.text.foo) } v = 0x1000; // A2 .data : { *(.text.data) }} v = 0x2000; // A3 } ``` In the first evaluation of A1, u is assigned the value `0`. On encountering '.data' output section, the layout is recomputed, and this time when A1 is recomputed, u is assigned the value `0x1000` because A2 was evaluated in the last pass. The value `0x1000` is incorrect for `u` because the value of `v` that is to be used in A1 must come from the last evaluation of `v`, that is, A3. Reusing values from the last pass in this case is error-prone and can lead to incorrect layouts. **It is difficult to add logic for when to reuse symbol values and when to reset them because these two types of layout recomputations can be intermixed.** Adding a source assignment node with the symbol expression node makes the recomputation simpler by obviating the need to reset the symbol values in both the cases. *The key idea is that the value of a symbol node of an absolute symbol is not the value of the corresponding symbol, but instead is the result of the last assignment node for that symbol.* Adding the source assignment with a symbol node has additional benefits as well: 1) It makes it easier to determine the culprit / closest assignment to use in diagnostics when a symbol value is not converging. 2) It makes it easier to add heuristics such as constant expression evaluation to speed up the layout convergence. For example: ``` u = v; .foo (u) : { *(.text.foo) } v = 0x2000; ``` In this case, if the symbol v encodes the source assignment, then we can easily add heuristic to determine if `v` source assignment can be evaluated early. 3) Selectively recompute only those assignment nodes which needs to be recomputed. If we reset symbol values, then all the assignment nodes always needs to be recomputed in each layout pass. Resolves qualcomm#468 Signed-off-by: Parth Arora <partaror@qti.qualcomm.com>

quic-seaswara

I could not follow which case does this patch handle ?

quic-seaswara · 2025-12-30T17:52:34Z

lib/Script/Expression.cpp

  if (!ThisSymbol)
    ThisSymbol = ThisModule.getNamePool().findSymbol(Name);

+  if (!SourceAssignment && ThisSymbol->resolveInfo()->isAbsolute()) {


should this be isScriptDefined() ?

I think isScriptDefined would work as well. Is there any case where an absolute symbol may not be script defined?

You can use assembly using .set

quic-seaswara · 2025-12-30T17:54:14Z

lib/Target/GNULDBackend.cpp

    return false;
  }

+  // FIXME: Adding more symbols this late can cause layout issues.


magic symbols are defined before layout, why would this cause issue ?

We are defining these symbols after the layout is performed, right? The layout is performed above this, at line 3079, in the relax function call.

quic-seaswara · 2025-12-30T17:54:34Z

lib/Script/Assignment.cpp

  }

+  auto &Backend = CurModule.getBackend();
+  Backend.updateLatestAssignment(Name, this);


wont this cause issues if the symbol assignment is PROVIDE ?

No, this does not change how PROVIDE assignments are evaluated. Why do you think it would cause issues with PROVIDE?

quic-seaswara · 2025-12-30T17:55:10Z

include/eld/Target/GNULDBackend.h

+
+  void updateLatestAssignment(llvm::StringRef SymName, const Assignment *A) {
+    SymbolNameToLatestAssignment[SymName] = A;
+  }


Why backend ? can we store this in LinkerScript ?

They are used during the layout computation. Currently, the entire logic for layout computation is in GNULDBackend.

The latest assignment would then become PROVIDE which will not be provided because of the preceding assignment ?

Assignment::assign for a PROVIDE assignment is only called if the assignment is indeed provided.

quic-seaswara reviewed Dec 30, 2025

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Add source assignment in symbol nodes #679

Add source assignment in symbol nodes #679

parth-07 commented Dec 29, 2025

Uh oh!

quic-seaswara left a comment

Uh oh!

quic-seaswara Dec 30, 2025

Uh oh!

parth-07 Dec 30, 2025

Uh oh!

quic-seaswara Dec 30, 2025

Uh oh!

quic-seaswara Dec 30, 2025

Uh oh!

parth-07 Dec 30, 2025

Uh oh!

quic-seaswara Dec 30, 2025

Uh oh!

parth-07 Dec 30, 2025

Uh oh!

quic-seaswara Dec 30, 2025

Uh oh!

parth-07 Dec 30, 2025

Uh oh!

quic-seaswara Dec 30, 2025

Uh oh!

parth-07 Dec 30, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

Add source assignment in symbol nodes #679

Are you sure you want to change the base?

Add source assignment in symbol nodes #679

Conversation

parth-07 commented Dec 29, 2025

Uh oh!

quic-seaswara left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants