@@ -575,7 +575,7 @@ bool Writer::createThunks(OutputSection *os, int margin) {
575
575
576
576
// Create a code map for CHPE metadata.
577
577
void Writer::createECCodeMap () {
578
- if (!isArm64EC ( ctx.config . machine ) )
578
+ if (!ctx.symtabEC )
579
579
return ;
580
580
581
581
// Clear the map in case we were're recomputing the map after adding
@@ -611,7 +611,8 @@ void Writer::createECCodeMap() {
611
611
612
612
closeRange ();
613
613
614
- Symbol *tableCountSym = ctx.symtab .findUnderscore (" __hybrid_code_map_count" );
614
+ Symbol *tableCountSym =
615
+ ctx.symtabEC ->findUnderscore (" __hybrid_code_map_count" );
615
616
cast<DefinedAbsolute>(tableCountSym)->setVA (codeMap.size ());
616
617
}
617
618
@@ -1229,8 +1230,7 @@ void Writer::createMiscChunks() {
1229
1230
// Create /guard:cf tables if requested.
1230
1231
createGuardCFTables ();
1231
1232
1232
- if (isArm64EC (config->machine ))
1233
- createECChunks ();
1233
+ createECChunks ();
1234
1234
1235
1235
if (config->autoImport )
1236
1236
createRuntimePseudoRelocs ();
@@ -2158,7 +2158,11 @@ void Writer::maybeAddRVATable(SymbolRVASet tableSymbols, StringRef tableSym,
2158
2158
2159
2159
// Create CHPE metadata chunks.
2160
2160
void Writer::createECChunks () {
2161
- for (Symbol *s : ctx.symtab .expSymbols ) {
2161
+ SymbolTable *symtab = ctx.symtabEC ;
2162
+ if (!symtab)
2163
+ return ;
2164
+
2165
+ for (Symbol *s : symtab->expSymbols ) {
2162
2166
auto sym = dyn_cast<Defined>(s);
2163
2167
if (!sym || !sym->getChunk ())
2164
2168
continue ;
@@ -2177,9 +2181,9 @@ void Writer::createECChunks() {
2177
2181
// we should use the #foo$hp_target symbol as the redirection target.
2178
2182
// First, try to look up the $hp_target symbol. If it can't be found,
2179
2183
// assume it's a regular function and look for #foo instead.
2180
- Symbol *targetSym = ctx. symtab . find ((targetName + " $hp_target" ).str ());
2184
+ Symbol *targetSym = symtab-> find ((targetName + " $hp_target" ).str ());
2181
2185
if (!targetSym)
2182
- targetSym = ctx. symtab . find (targetName);
2186
+ targetSym = symtab-> find (targetName);
2183
2187
Defined *t = dyn_cast_or_null<Defined>(targetSym);
2184
2188
if (t && isArm64EC (t->getChunk ()->getMachine ()))
2185
2189
exportThunks.push_back ({chunk, t});
@@ -2188,20 +2192,20 @@ void Writer::createECChunks() {
2188
2192
2189
2193
auto codeMapChunk = make<ECCodeMapChunk>(codeMap);
2190
2194
rdataSec->addChunk (codeMapChunk);
2191
- Symbol *codeMapSym = ctx. symtab . findUnderscore (" __hybrid_code_map" );
2195
+ Symbol *codeMapSym = symtab-> findUnderscore (" __hybrid_code_map" );
2192
2196
replaceSymbol<DefinedSynthetic>(codeMapSym, codeMapSym->getName (),
2193
2197
codeMapChunk);
2194
2198
2195
2199
CHPECodeRangesChunk *ranges = make<CHPECodeRangesChunk>(exportThunks);
2196
2200
rdataSec->addChunk (ranges);
2197
2201
Symbol *rangesSym =
2198
- ctx. symtab . findUnderscore (" __x64_code_ranges_to_entry_points" );
2202
+ symtab-> findUnderscore (" __x64_code_ranges_to_entry_points" );
2199
2203
replaceSymbol<DefinedSynthetic>(rangesSym, rangesSym->getName (), ranges);
2200
2204
2201
2205
CHPERedirectionChunk *entryPoints = make<CHPERedirectionChunk>(exportThunks);
2202
2206
a64xrmSec->addChunk (entryPoints);
2203
2207
Symbol *entryPointsSym =
2204
- ctx. symtab . findUnderscore (" __arm64x_redirection_metadata" );
2208
+ symtab-> findUnderscore (" __arm64x_redirection_metadata" );
2205
2209
replaceSymbol<DefinedSynthetic>(entryPointsSym, entryPointsSym->getName (),
2206
2210
entryPoints);
2207
2211
}
@@ -2294,53 +2298,54 @@ void Writer::setSectionPermissions() {
2294
2298
2295
2299
// Set symbols used by ARM64EC metadata.
2296
2300
void Writer::setECSymbols () {
2297
- if (!isArm64EC (ctx.config .machine ))
2301
+ SymbolTable *symtab = ctx.symtabEC ;
2302
+ if (!symtab)
2298
2303
return ;
2299
2304
2300
2305
llvm::stable_sort (exportThunks, [](const std::pair<Chunk *, Defined *> &a,
2301
2306
const std::pair<Chunk *, Defined *> &b) {
2302
2307
return a.first ->getRVA () < b.first ->getRVA ();
2303
2308
});
2304
2309
2305
- Symbol *rfeTableSym = ctx. symtab . findUnderscore (" __arm64x_extra_rfe_table" );
2310
+ Symbol *rfeTableSym = symtab-> findUnderscore (" __arm64x_extra_rfe_table" );
2306
2311
replaceSymbol<DefinedSynthetic>(rfeTableSym, " __arm64x_extra_rfe_table" ,
2307
2312
pdata.first );
2308
2313
2309
2314
if (pdata.first ) {
2310
2315
Symbol *rfeSizeSym =
2311
- ctx. symtab . findUnderscore (" __arm64x_extra_rfe_table_size" );
2316
+ symtab-> findUnderscore (" __arm64x_extra_rfe_table_size" );
2312
2317
cast<DefinedAbsolute>(rfeSizeSym)
2313
2318
->setVA (pdata.last ->getRVA () + pdata.last ->getSize () -
2314
2319
pdata.first ->getRVA ());
2315
2320
}
2316
2321
2317
2322
Symbol *rangesCountSym =
2318
- ctx. symtab . findUnderscore (" __x64_code_ranges_to_entry_points_count" );
2323
+ symtab-> findUnderscore (" __x64_code_ranges_to_entry_points_count" );
2319
2324
cast<DefinedAbsolute>(rangesCountSym)->setVA (exportThunks.size ());
2320
2325
2321
2326
Symbol *entryPointCountSym =
2322
- ctx. symtab . findUnderscore (" __arm64x_redirection_metadata_count" );
2327
+ symtab-> findUnderscore (" __arm64x_redirection_metadata_count" );
2323
2328
cast<DefinedAbsolute>(entryPointCountSym)->setVA (exportThunks.size ());
2324
2329
2325
- Symbol *iatSym = ctx. symtab . findUnderscore (" __hybrid_auxiliary_iat" );
2330
+ Symbol *iatSym = symtab-> findUnderscore (" __hybrid_auxiliary_iat" );
2326
2331
replaceSymbol<DefinedSynthetic>(iatSym, " __hybrid_auxiliary_iat" ,
2327
2332
idata.auxIat .empty () ? nullptr
2328
2333
: idata.auxIat .front ());
2329
2334
2330
- Symbol *iatCopySym = ctx. symtab . findUnderscore (" __hybrid_auxiliary_iat_copy" );
2335
+ Symbol *iatCopySym = symtab-> findUnderscore (" __hybrid_auxiliary_iat_copy" );
2331
2336
replaceSymbol<DefinedSynthetic>(
2332
2337
iatCopySym, " __hybrid_auxiliary_iat_copy" ,
2333
2338
idata.auxIatCopy .empty () ? nullptr : idata.auxIatCopy .front ());
2334
2339
2335
2340
Symbol *delayIatSym =
2336
- ctx. symtab . findUnderscore (" __hybrid_auxiliary_delayload_iat" );
2341
+ symtab-> findUnderscore (" __hybrid_auxiliary_delayload_iat" );
2337
2342
replaceSymbol<DefinedSynthetic>(
2338
2343
delayIatSym, " __hybrid_auxiliary_delayload_iat" ,
2339
2344
delayIdata.getAuxIat ().empty () ? nullptr
2340
2345
: delayIdata.getAuxIat ().front ());
2341
2346
2342
2347
Symbol *delayIatCopySym =
2343
- ctx. symtab . findUnderscore (" __hybrid_auxiliary_delayload_iat_copy" );
2348
+ symtab-> findUnderscore (" __hybrid_auxiliary_delayload_iat_copy" );
2344
2349
replaceSymbol<DefinedSynthetic>(
2345
2350
delayIatCopySym, " __hybrid_auxiliary_delayload_iat_copy" ,
2346
2351
delayIdata.getAuxIatCopy ().empty () ? nullptr
@@ -2695,6 +2700,23 @@ void Writer::prepareLoadConfig(SymbolTable &symtab, T *loadConfig) {
2695
2700
}
2696
2701
}
2697
2702
2703
+ IF_CONTAINS (CHPEMetadataPointer) {
2704
+ // On ARM64X, only the EC version of the load config contains
2705
+ // CHPEMetadataPointer. Copy its value to the native load config.
2706
+ if (ctx.hybridSymtab && !symtab.isEC () &&
2707
+ ctx.hybridSymtab ->loadConfigSize >=
2708
+ offsetof (T, CHPEMetadataPointer) + sizeof (T::CHPEMetadataPointer)) {
2709
+ OutputSection *sec =
2710
+ ctx.getOutputSection (ctx.hybridSymtab ->loadConfigSym ->getChunk ());
2711
+ uint8_t *secBuf = buffer->getBufferStart () + sec->getFileOff ();
2712
+ auto hybridLoadConfig =
2713
+ reinterpret_cast <const coff_load_configuration64 *>(
2714
+ secBuf +
2715
+ (ctx.hybridSymtab ->loadConfigSym ->getRVA () - sec->getRVA ()));
2716
+ loadConfig->CHPEMetadataPointer = hybridLoadConfig->CHPEMetadataPointer ;
2717
+ }
2718
+ }
2719
+
2698
2720
if (ctx.config .guardCF == GuardCFLevel::Off)
2699
2721
return ;
2700
2722
RETURN_IF_NOT_CONTAINS (GuardFlags)
0 commit comments