https://github.com/ayokunle321 created https://github.com/llvm/llvm-project/pull/203154
### Summary Stage 1 of the sloc-dedup work. Adds detection and measurement of duplicate file entries in the loaded SLoc address space. There is no reuse yet and no behavior change in default builds. ### Motivation When multiple modules import the same header, each one reserves its own offset space for that file. Before doing anything invasive, we want to confirm the duplication is real and measure exactly how much is reclaimable. ### Implementation SourceManager gains a DenseMap<const FileEntry*, UIntTy> of first-seen offsets plus NumDuplicateLoadedFiles and DuplicateLoadedBytes counters, reported in -print-stats. ASTReader runs a small eager scan in the SOURCE_LOCATION_OFFSETS case and feeds each SM_SLOC_FILE_ENTRY's file and size into SourceManager. Detection lives at the eager allocation site because that's where offset space is actually reserved. A lazy hook in ReadSLocEntry was tried first but did not fire for most entries. Gated behind CLANG_SLOC_DEDUP=1 so default builds and lit are unaffected. ### Results Using the two-module reproducer in `dedup-test/`, where both modules import `shared.h`, the one-module baseline loaded 43,764 bytes of SLoc data and reported no duplicates. Adding the second module increased the loaded SLoc space to 87,528 bytes and identified 2 duplicate file allocations, corresponding to 20,694 bytes that could be reused (about 24% of the loaded space). The duplicates were `shared.h` itself and the module map. The one-module baseline reports zero duplicates, suggesting the detection is not producing false positives. Stage 2 will focus on reclaiming those 20,694 bytes. >From cb3ad6379f2b4cf3dcae00388b96a3adf9ddb207 Mon Sep 17 00:00:00 2001 From: Ayokunle Amodu <[email protected]> Date: Wed, 10 Jun 2026 22:10:56 -0400 Subject: [PATCH 1/2] added dedup prototype --- .gitignore | 1 + clang/include/clang/Basic/SourceManager.h | 26 +++++++++++++++++++++++ clang/lib/Basic/SourceManager.cpp | 5 +++++ clang/lib/Serialization/ASTReader.cpp | 5 +++++ 4 files changed, 37 insertions(+) diff --git a/.gitignore b/.gitignore index 9d4e86ab10caa..67f2c8a0a6f95 100644 --- a/.gitignore +++ b/.gitignore @@ -28,6 +28,7 @@ # Nested build directory /build* +/test* #==============================================================================# # Explicit files to ignore (only matches one). diff --git a/clang/include/clang/Basic/SourceManager.h b/clang/include/clang/Basic/SourceManager.h index 4217b8683da1e..04665ff035ec7 100644 --- a/clang/include/clang/Basic/SourceManager.h +++ b/clang/include/clang/Basic/SourceManager.h @@ -749,6 +749,32 @@ class SourceManager : public RefCountedBase<SourceManager> { static const SourceLocation::UIntTy MaxLoadedOffset = 1ULL << (8 * sizeof(SourceLocation::UIntTy) - 1); + /// --- Source-location de-duplication: detection (prototype, Stage 1) --- + /// The first global offset at which each file's SLoc entry was loaded. + /// Lets us recognize when a later module re-loads a file already present in + /// the loaded address space (e.g. a header included by several modules). + llvm::DenseMap<const FileEntry *, SourceLocation::UIntTy> LoadedFileFirstOffset; + /// Number of loaded file SLoc entries that duplicated an already-loaded file. + unsigned NumDuplicateLoadedFiles = 0; + /// SLoc address-space bytes occupied by those duplicate entries (the prize + /// that reuse could reclaim). + uint64_t DuplicateLoadedBytes = 0; + +public: + /// Record that a loaded file SLoc entry was created. If the same file was + /// already loaded into the address space, it is counted as a duplicate. + void noteLoadedFileSLocEntry(const FileEntry *FE, + SourceLocation::UIntTy Offset, uint64_t Size) { + if (!FE) + return; + auto Res = LoadedFileFirstOffset.try_emplace(FE, Offset); + if (!Res.second) { + ++NumDuplicateLoadedFiles; + DuplicateLoadedBytes += Size; + } + } + +private: /// A bitmap that indicates whether the entries of LoadedSLocEntryTable /// have already been loaded from the external source. /// diff --git a/clang/lib/Basic/SourceManager.cpp b/clang/lib/Basic/SourceManager.cpp index b6cc6ec9365f5..70597f2c56457 100644 --- a/clang/lib/Basic/SourceManager.cpp +++ b/clang/lib/Basic/SourceManager.cpp @@ -2125,6 +2125,11 @@ void SourceManager::PrintStats() const { << " bytes of capacity), " << MaxLoadedOffset - CurrentLoadedOffset << "B of SLoc address space used.\n"; + if (NumDuplicateLoadedFiles) + llvm::errs() << NumDuplicateLoadedFiles + << " duplicate loaded file SLocEntries detected (" + << DuplicateLoadedBytes + << "B of SLoc address space reusable).\n"; unsigned NumLineNumsComputed = 0; unsigned NumFileBytesMapped = 0; diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp index f8a6a38bb9b5c..09ad43c03dfe2 100644 --- a/clang/lib/Serialization/ASTReader.cpp +++ b/clang/lib/Serialization/ASTReader.cpp @@ -2004,6 +2004,11 @@ bool ASTReader::ReadSLocEntry(int ID) { FileCharacter = (SrcMgr::CharacteristicKind)Record[2]; FileID FID = SourceMgr.createFileID(*File, IncludeLoc, FileCharacter, ID, BaseOffset + Record[0]); + // Stage 1 (de-dup prototype): detect when this file's SLoc entry duplicates + // one already loaded by an earlier module, and measure the reusable bytes. + SourceMgr.noteLoadedFileSLocEntry(&File->getFileEntry(), + BaseOffset + Record[0], + File->getSize() + 1); SrcMgr::FileInfo &FileInfo = SourceMgr.getSLocEntry(FID).getFile(); FileInfo.NumCreatedFIDs = Record[5]; if (Record[3]) >From 728ca6daca8f326ce163d28e71a35bed356c2fc4 Mon Sep 17 00:00:00 2001 From: Ayokunle Amodu <[email protected]> Date: Wed, 10 Jun 2026 22:34:53 -0400 Subject: [PATCH 2/2] eagerly scan module's sloc file entries --- clang/include/clang/Basic/SourceManager.h | 1 - clang/lib/Serialization/ASTReader.cpp | 49 ++- dedup-test/a.h | 5 + dedup-test/b.h | 5 + dedup-test/module.modulemap | 2 + dedup-test/shared.h | 403 ++++++++++++++++++++++ dedup-test/use.cpp | 3 + dedup-test/use_err.cpp | 7 + 8 files changed, 469 insertions(+), 6 deletions(-) create mode 100644 dedup-test/a.h create mode 100644 dedup-test/b.h create mode 100644 dedup-test/module.modulemap create mode 100644 dedup-test/shared.h create mode 100644 dedup-test/use.cpp create mode 100644 dedup-test/use_err.cpp diff --git a/clang/include/clang/Basic/SourceManager.h b/clang/include/clang/Basic/SourceManager.h index 04665ff035ec7..733574d4118ec 100644 --- a/clang/include/clang/Basic/SourceManager.h +++ b/clang/include/clang/Basic/SourceManager.h @@ -749,7 +749,6 @@ class SourceManager : public RefCountedBase<SourceManager> { static const SourceLocation::UIntTy MaxLoadedOffset = 1ULL << (8 * sizeof(SourceLocation::UIntTy) - 1); - /// --- Source-location de-duplication: detection (prototype, Stage 1) --- /// The first global offset at which each file's SLoc entry was loaded. /// Lets us recognize when a later module re-loads a file already present in /// the loaded address space (e.g. a header included by several modules). diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp index 09ad43c03dfe2..bb99376c8e31f 100644 --- a/clang/lib/Serialization/ASTReader.cpp +++ b/clang/lib/Serialization/ASTReader.cpp @@ -2004,11 +2004,6 @@ bool ASTReader::ReadSLocEntry(int ID) { FileCharacter = (SrcMgr::CharacteristicKind)Record[2]; FileID FID = SourceMgr.createFileID(*File, IncludeLoc, FileCharacter, ID, BaseOffset + Record[0]); - // Stage 1 (de-dup prototype): detect when this file's SLoc entry duplicates - // one already loaded by an earlier module, and measure the reusable bytes. - SourceMgr.noteLoadedFileSLocEntry(&File->getFileEntry(), - BaseOffset + Record[0], - File->getSize() + 1); SrcMgr::FileInfo &FileInfo = SourceMgr.getSLocEntry(FID).getFile(); FileInfo.NumCreatedFIDs = Record[5]; if (Record[3]) @@ -4255,6 +4250,50 @@ llvm::Error ASTReader::ReadASTBlock(ModuleFile &F, - SLocSpaceSize,&F)); TotalNumSLocEntries += F.LocalNumSLocEntries; + + // Eagerly scan this module's SLoc file + // entries to detect ones that duplicate a file already loaded by an + // earlier module, and measure the reusable address space. + // + // Gated by an env var so normal builds and the test suite + // are unaffected. + static const bool DedupDetect = ::getenv("CLANG_SLOC_DEDUP") != nullptr; + if (DedupDetect) { + unsigned N = F.LocalNumSLocEntries; + SavedStreamPosition SavedPos(F.SLocEntryCursor); + SmallVector<uint32_t, 64> Offs(N, 0); + SmallVector<const FileEntry *, 64> Files(N, nullptr); + bool ScanOK = true; + for (unsigned i = 0; i != N && ScanOK; ++i) { + if (llvm::Error Err = F.SLocEntryCursor.JumpToBit( + F.SLocEntryOffsetsBase + F.SLocEntryOffsets[i])) { + consumeError(std::move(Err)); + ScanOK = false; + break; + } + Expected<llvm::BitstreamEntry> E = F.SLocEntryCursor.advance(); + if (!E) { consumeError(E.takeError()); ScanOK = false; break; } + if (E->Kind != llvm::BitstreamEntry::Record) { ScanOK = false; break; } + RecordData R; + StringRef B; + Expected<unsigned> C = F.SLocEntryCursor.readRecord(E->ID, R, &B); + if (!C) { consumeError(C.takeError()); ScanOK = false; break; } + Offs[i] = (uint32_t)R[0]; + if (C.get() == SM_SLOC_FILE_ENTRY) + if (OptionalFileEntryRef File = getInputFile(F, R[4]).getFile()) + Files[i] = &File->getFileEntry(); + } + if (ScanOK) { + for (unsigned i = 0; i != N; ++i) { + if (!Files[i]) + continue; + uint64_t Size = + (uint64_t)((i + 1 < N ? Offs[i + 1] : SLocSpaceSize) - Offs[i]); + SourceMgr.noteLoadedFileSLocEntry( + Files[i], F.SLocEntryBaseOffset + Offs[i], Size); + } + } + } break; } diff --git a/dedup-test/a.h b/dedup-test/a.h new file mode 100644 index 0000000000000..1fe7fc27db549 --- /dev/null +++ b/dedup-test/a.h @@ -0,0 +1,5 @@ +#ifndef A_H +#define A_H +#include "shared.h" +inline int a_entry(int x) { return shared_fn_0(x); } +#endif diff --git a/dedup-test/b.h b/dedup-test/b.h new file mode 100644 index 0000000000000..85839261fc602 --- /dev/null +++ b/dedup-test/b.h @@ -0,0 +1,5 @@ +#ifndef B_H +#define B_H +#include "shared.h" +inline int b_entry(int x) { return shared_fn_1(x); } +#endif diff --git a/dedup-test/module.modulemap b/dedup-test/module.modulemap new file mode 100644 index 0000000000000..2da1c03a22211 --- /dev/null +++ b/dedup-test/module.modulemap @@ -0,0 +1,2 @@ +module A { header "a.h" export * } +module B { header "b.h" export * } diff --git a/dedup-test/shared.h b/dedup-test/shared.h new file mode 100644 index 0000000000000..3ac57a45355f9 --- /dev/null +++ b/dedup-test/shared.h @@ -0,0 +1,403 @@ +#ifndef SHARED_H +#define SHARED_H +inline int shared_fn_0(int x) { return x + 0; } +inline int shared_fn_1(int x) { return x + 1; } +inline int shared_fn_2(int x) { return x + 2; } +inline int shared_fn_3(int x) { return x + 3; } +inline int shared_fn_4(int x) { return x + 4; } +inline int shared_fn_5(int x) { return x + 5; } +inline int shared_fn_6(int x) { return x + 6; } +inline int shared_fn_7(int x) { return x + 7; } +inline int shared_fn_8(int x) { return x + 8; } +inline int shared_fn_9(int x) { return x + 9; } +inline int shared_fn_10(int x) { return x + 10; } +inline int shared_fn_11(int x) { return x + 11; } +inline int shared_fn_12(int x) { return x + 12; } +inline int shared_fn_13(int x) { return x + 13; } +inline int shared_fn_14(int x) { return x + 14; } +inline int shared_fn_15(int x) { return x + 15; } +inline int shared_fn_16(int x) { return x + 16; } +inline int shared_fn_17(int x) { return x + 17; } +inline int shared_fn_18(int x) { return x + 18; } +inline int shared_fn_19(int x) { return x + 19; } +inline int shared_fn_20(int x) { return x + 20; } +inline int shared_fn_21(int x) { return x + 21; } +inline int shared_fn_22(int x) { return x + 22; } +inline int shared_fn_23(int x) { return x + 23; } +inline int shared_fn_24(int x) { return x + 24; } +inline int shared_fn_25(int x) { return x + 25; } +inline int shared_fn_26(int x) { return x + 26; } +inline int shared_fn_27(int x) { return x + 27; } +inline int shared_fn_28(int x) { return x + 28; } +inline int shared_fn_29(int x) { return x + 29; } +inline int shared_fn_30(int x) { return x + 30; } +inline int shared_fn_31(int x) { return x + 31; } +inline int shared_fn_32(int x) { return x + 32; } +inline int shared_fn_33(int x) { return x + 33; } +inline int shared_fn_34(int x) { return x + 34; } +inline int shared_fn_35(int x) { return x + 35; } +inline int shared_fn_36(int x) { return x + 36; } +inline int shared_fn_37(int x) { return x + 37; } +inline int shared_fn_38(int x) { return x + 38; } +inline int shared_fn_39(int x) { return x + 39; } +inline int shared_fn_40(int x) { return x + 40; } +inline int shared_fn_41(int x) { return x + 41; } +inline int shared_fn_42(int x) { return x + 42; } +inline int shared_fn_43(int x) { return x + 43; } +inline int shared_fn_44(int x) { return x + 44; } +inline int shared_fn_45(int x) { return x + 45; } +inline int shared_fn_46(int x) { return x + 46; } +inline int shared_fn_47(int x) { return x + 47; } +inline int shared_fn_48(int x) { return x + 48; } +inline int shared_fn_49(int x) { return x + 49; } +inline int shared_fn_50(int x) { return x + 50; } +inline int shared_fn_51(int x) { return x + 51; } +inline int shared_fn_52(int x) { return x + 52; } +inline int shared_fn_53(int x) { return x + 53; } +inline int shared_fn_54(int x) { return x + 54; } +inline int shared_fn_55(int x) { return x + 55; } +inline int shared_fn_56(int x) { return x + 56; } +inline int shared_fn_57(int x) { return x + 57; } +inline int shared_fn_58(int x) { return x + 58; } +inline int shared_fn_59(int x) { return x + 59; } +inline int shared_fn_60(int x) { return x + 60; } +inline int shared_fn_61(int x) { return x + 61; } +inline int shared_fn_62(int x) { return x + 62; } +inline int shared_fn_63(int x) { return x + 63; } +inline int shared_fn_64(int x) { return x + 64; } +inline int shared_fn_65(int x) { return x + 65; } +inline int shared_fn_66(int x) { return x + 66; } +inline int shared_fn_67(int x) { return x + 67; } +inline int shared_fn_68(int x) { return x + 68; } +inline int shared_fn_69(int x) { return x + 69; } +inline int shared_fn_70(int x) { return x + 70; } +inline int shared_fn_71(int x) { return x + 71; } +inline int shared_fn_72(int x) { return x + 72; } +inline int shared_fn_73(int x) { return x + 73; } +inline int shared_fn_74(int x) { return x + 74; } +inline int shared_fn_75(int x) { return x + 75; } +inline int shared_fn_76(int x) { return x + 76; } +inline int shared_fn_77(int x) { return x + 77; } +inline int shared_fn_78(int x) { return x + 78; } +inline int shared_fn_79(int x) { return x + 79; } +inline int shared_fn_80(int x) { return x + 80; } +inline int shared_fn_81(int x) { return x + 81; } +inline int shared_fn_82(int x) { return x + 82; } +inline int shared_fn_83(int x) { return x + 83; } +inline int shared_fn_84(int x) { return x + 84; } +inline int shared_fn_85(int x) { return x + 85; } +inline int shared_fn_86(int x) { return x + 86; } +inline int shared_fn_87(int x) { return x + 87; } +inline int shared_fn_88(int x) { return x + 88; } +inline int shared_fn_89(int x) { return x + 89; } +inline int shared_fn_90(int x) { return x + 90; } +inline int shared_fn_91(int x) { return x + 91; } +inline int shared_fn_92(int x) { return x + 92; } +inline int shared_fn_93(int x) { return x + 93; } +inline int shared_fn_94(int x) { return x + 94; } +inline int shared_fn_95(int x) { return x + 95; } +inline int shared_fn_96(int x) { return x + 96; } +inline int shared_fn_97(int x) { return x + 97; } +inline int shared_fn_98(int x) { return x + 98; } +inline int shared_fn_99(int x) { return x + 99; } +inline int shared_fn_100(int x) { return x + 100; } +inline int shared_fn_101(int x) { return x + 101; } +inline int shared_fn_102(int x) { return x + 102; } +inline int shared_fn_103(int x) { return x + 103; } +inline int shared_fn_104(int x) { return x + 104; } +inline int shared_fn_105(int x) { return x + 105; } +inline int shared_fn_106(int x) { return x + 106; } +inline int shared_fn_107(int x) { return x + 107; } +inline int shared_fn_108(int x) { return x + 108; } +inline int shared_fn_109(int x) { return x + 109; } +inline int shared_fn_110(int x) { return x + 110; } +inline int shared_fn_111(int x) { return x + 111; } +inline int shared_fn_112(int x) { return x + 112; } +inline int shared_fn_113(int x) { return x + 113; } +inline int shared_fn_114(int x) { return x + 114; } +inline int shared_fn_115(int x) { return x + 115; } +inline int shared_fn_116(int x) { return x + 116; } +inline int shared_fn_117(int x) { return x + 117; } +inline int shared_fn_118(int x) { return x + 118; } +inline int shared_fn_119(int x) { return x + 119; } +inline int shared_fn_120(int x) { return x + 120; } +inline int shared_fn_121(int x) { return x + 121; } +inline int shared_fn_122(int x) { return x + 122; } +inline int shared_fn_123(int x) { return x + 123; } +inline int shared_fn_124(int x) { return x + 124; } +inline int shared_fn_125(int x) { return x + 125; } +inline int shared_fn_126(int x) { return x + 126; } +inline int shared_fn_127(int x) { return x + 127; } +inline int shared_fn_128(int x) { return x + 128; } +inline int shared_fn_129(int x) { return x + 129; } +inline int shared_fn_130(int x) { return x + 130; } +inline int shared_fn_131(int x) { return x + 131; } +inline int shared_fn_132(int x) { return x + 132; } +inline int shared_fn_133(int x) { return x + 133; } +inline int shared_fn_134(int x) { return x + 134; } +inline int shared_fn_135(int x) { return x + 135; } +inline int shared_fn_136(int x) { return x + 136; } +inline int shared_fn_137(int x) { return x + 137; } +inline int shared_fn_138(int x) { return x + 138; } +inline int shared_fn_139(int x) { return x + 139; } +inline int shared_fn_140(int x) { return x + 140; } +inline int shared_fn_141(int x) { return x + 141; } +inline int shared_fn_142(int x) { return x + 142; } +inline int shared_fn_143(int x) { return x + 143; } +inline int shared_fn_144(int x) { return x + 144; } +inline int shared_fn_145(int x) { return x + 145; } +inline int shared_fn_146(int x) { return x + 146; } +inline int shared_fn_147(int x) { return x + 147; } +inline int shared_fn_148(int x) { return x + 148; } +inline int shared_fn_149(int x) { return x + 149; } +inline int shared_fn_150(int x) { return x + 150; } +inline int shared_fn_151(int x) { return x + 151; } +inline int shared_fn_152(int x) { return x + 152; } +inline int shared_fn_153(int x) { return x + 153; } +inline int shared_fn_154(int x) { return x + 154; } +inline int shared_fn_155(int x) { return x + 155; } +inline int shared_fn_156(int x) { return x + 156; } +inline int shared_fn_157(int x) { return x + 157; } +inline int shared_fn_158(int x) { return x + 158; } +inline int shared_fn_159(int x) { return x + 159; } +inline int shared_fn_160(int x) { return x + 160; } +inline int shared_fn_161(int x) { return x + 161; } +inline int shared_fn_162(int x) { return x + 162; } +inline int shared_fn_163(int x) { return x + 163; } +inline int shared_fn_164(int x) { return x + 164; } +inline int shared_fn_165(int x) { return x + 165; } +inline int shared_fn_166(int x) { return x + 166; } +inline int shared_fn_167(int x) { return x + 167; } +inline int shared_fn_168(int x) { return x + 168; } +inline int shared_fn_169(int x) { return x + 169; } +inline int shared_fn_170(int x) { return x + 170; } +inline int shared_fn_171(int x) { return x + 171; } +inline int shared_fn_172(int x) { return x + 172; } +inline int shared_fn_173(int x) { return x + 173; } +inline int shared_fn_174(int x) { return x + 174; } +inline int shared_fn_175(int x) { return x + 175; } +inline int shared_fn_176(int x) { return x + 176; } +inline int shared_fn_177(int x) { return x + 177; } +inline int shared_fn_178(int x) { return x + 178; } +inline int shared_fn_179(int x) { return x + 179; } +inline int shared_fn_180(int x) { return x + 180; } +inline int shared_fn_181(int x) { return x + 181; } +inline int shared_fn_182(int x) { return x + 182; } +inline int shared_fn_183(int x) { return x + 183; } +inline int shared_fn_184(int x) { return x + 184; } +inline int shared_fn_185(int x) { return x + 185; } +inline int shared_fn_186(int x) { return x + 186; } +inline int shared_fn_187(int x) { return x + 187; } +inline int shared_fn_188(int x) { return x + 188; } +inline int shared_fn_189(int x) { return x + 189; } +inline int shared_fn_190(int x) { return x + 190; } +inline int shared_fn_191(int x) { return x + 191; } +inline int shared_fn_192(int x) { return x + 192; } +inline int shared_fn_193(int x) { return x + 193; } +inline int shared_fn_194(int x) { return x + 194; } +inline int shared_fn_195(int x) { return x + 195; } +inline int shared_fn_196(int x) { return x + 196; } +inline int shared_fn_197(int x) { return x + 197; } +inline int shared_fn_198(int x) { return x + 198; } +inline int shared_fn_199(int x) { return x + 199; } +inline int shared_fn_200(int x) { return x + 200; } +inline int shared_fn_201(int x) { return x + 201; } +inline int shared_fn_202(int x) { return x + 202; } +inline int shared_fn_203(int x) { return x + 203; } +inline int shared_fn_204(int x) { return x + 204; } +inline int shared_fn_205(int x) { return x + 205; } +inline int shared_fn_206(int x) { return x + 206; } +inline int shared_fn_207(int x) { return x + 207; } +inline int shared_fn_208(int x) { return x + 208; } +inline int shared_fn_209(int x) { return x + 209; } +inline int shared_fn_210(int x) { return x + 210; } +inline int shared_fn_211(int x) { return x + 211; } +inline int shared_fn_212(int x) { return x + 212; } +inline int shared_fn_213(int x) { return x + 213; } +inline int shared_fn_214(int x) { return x + 214; } +inline int shared_fn_215(int x) { return x + 215; } +inline int shared_fn_216(int x) { return x + 216; } +inline int shared_fn_217(int x) { return x + 217; } +inline int shared_fn_218(int x) { return x + 218; } +inline int shared_fn_219(int x) { return x + 219; } +inline int shared_fn_220(int x) { return x + 220; } +inline int shared_fn_221(int x) { return x + 221; } +inline int shared_fn_222(int x) { return x + 222; } +inline int shared_fn_223(int x) { return x + 223; } +inline int shared_fn_224(int x) { return x + 224; } +inline int shared_fn_225(int x) { return x + 225; } +inline int shared_fn_226(int x) { return x + 226; } +inline int shared_fn_227(int x) { return x + 227; } +inline int shared_fn_228(int x) { return x + 228; } +inline int shared_fn_229(int x) { return x + 229; } +inline int shared_fn_230(int x) { return x + 230; } +inline int shared_fn_231(int x) { return x + 231; } +inline int shared_fn_232(int x) { return x + 232; } +inline int shared_fn_233(int x) { return x + 233; } +inline int shared_fn_234(int x) { return x + 234; } +inline int shared_fn_235(int x) { return x + 235; } +inline int shared_fn_236(int x) { return x + 236; } +inline int shared_fn_237(int x) { return x + 237; } +inline int shared_fn_238(int x) { return x + 238; } +inline int shared_fn_239(int x) { return x + 239; } +inline int shared_fn_240(int x) { return x + 240; } +inline int shared_fn_241(int x) { return x + 241; } +inline int shared_fn_242(int x) { return x + 242; } +inline int shared_fn_243(int x) { return x + 243; } +inline int shared_fn_244(int x) { return x + 244; } +inline int shared_fn_245(int x) { return x + 245; } +inline int shared_fn_246(int x) { return x + 246; } +inline int shared_fn_247(int x) { return x + 247; } +inline int shared_fn_248(int x) { return x + 248; } +inline int shared_fn_249(int x) { return x + 249; } +inline int shared_fn_250(int x) { return x + 250; } +inline int shared_fn_251(int x) { return x + 251; } +inline int shared_fn_252(int x) { return x + 252; } +inline int shared_fn_253(int x) { return x + 253; } +inline int shared_fn_254(int x) { return x + 254; } +inline int shared_fn_255(int x) { return x + 255; } +inline int shared_fn_256(int x) { return x + 256; } +inline int shared_fn_257(int x) { return x + 257; } +inline int shared_fn_258(int x) { return x + 258; } +inline int shared_fn_259(int x) { return x + 259; } +inline int shared_fn_260(int x) { return x + 260; } +inline int shared_fn_261(int x) { return x + 261; } +inline int shared_fn_262(int x) { return x + 262; } +inline int shared_fn_263(int x) { return x + 263; } +inline int shared_fn_264(int x) { return x + 264; } +inline int shared_fn_265(int x) { return x + 265; } +inline int shared_fn_266(int x) { return x + 266; } +inline int shared_fn_267(int x) { return x + 267; } +inline int shared_fn_268(int x) { return x + 268; } +inline int shared_fn_269(int x) { return x + 269; } +inline int shared_fn_270(int x) { return x + 270; } +inline int shared_fn_271(int x) { return x + 271; } +inline int shared_fn_272(int x) { return x + 272; } +inline int shared_fn_273(int x) { return x + 273; } +inline int shared_fn_274(int x) { return x + 274; } +inline int shared_fn_275(int x) { return x + 275; } +inline int shared_fn_276(int x) { return x + 276; } +inline int shared_fn_277(int x) { return x + 277; } +inline int shared_fn_278(int x) { return x + 278; } +inline int shared_fn_279(int x) { return x + 279; } +inline int shared_fn_280(int x) { return x + 280; } +inline int shared_fn_281(int x) { return x + 281; } +inline int shared_fn_282(int x) { return x + 282; } +inline int shared_fn_283(int x) { return x + 283; } +inline int shared_fn_284(int x) { return x + 284; } +inline int shared_fn_285(int x) { return x + 285; } +inline int shared_fn_286(int x) { return x + 286; } +inline int shared_fn_287(int x) { return x + 287; } +inline int shared_fn_288(int x) { return x + 288; } +inline int shared_fn_289(int x) { return x + 289; } +inline int shared_fn_290(int x) { return x + 290; } +inline int shared_fn_291(int x) { return x + 291; } +inline int shared_fn_292(int x) { return x + 292; } +inline int shared_fn_293(int x) { return x + 293; } +inline int shared_fn_294(int x) { return x + 294; } +inline int shared_fn_295(int x) { return x + 295; } +inline int shared_fn_296(int x) { return x + 296; } +inline int shared_fn_297(int x) { return x + 297; } +inline int shared_fn_298(int x) { return x + 298; } +inline int shared_fn_299(int x) { return x + 299; } +inline int shared_fn_300(int x) { return x + 300; } +inline int shared_fn_301(int x) { return x + 301; } +inline int shared_fn_302(int x) { return x + 302; } +inline int shared_fn_303(int x) { return x + 303; } +inline int shared_fn_304(int x) { return x + 304; } +inline int shared_fn_305(int x) { return x + 305; } +inline int shared_fn_306(int x) { return x + 306; } +inline int shared_fn_307(int x) { return x + 307; } +inline int shared_fn_308(int x) { return x + 308; } +inline int shared_fn_309(int x) { return x + 309; } +inline int shared_fn_310(int x) { return x + 310; } +inline int shared_fn_311(int x) { return x + 311; } +inline int shared_fn_312(int x) { return x + 312; } +inline int shared_fn_313(int x) { return x + 313; } +inline int shared_fn_314(int x) { return x + 314; } +inline int shared_fn_315(int x) { return x + 315; } +inline int shared_fn_316(int x) { return x + 316; } +inline int shared_fn_317(int x) { return x + 317; } +inline int shared_fn_318(int x) { return x + 318; } +inline int shared_fn_319(int x) { return x + 319; } +inline int shared_fn_320(int x) { return x + 320; } +inline int shared_fn_321(int x) { return x + 321; } +inline int shared_fn_322(int x) { return x + 322; } +inline int shared_fn_323(int x) { return x + 323; } +inline int shared_fn_324(int x) { return x + 324; } +inline int shared_fn_325(int x) { return x + 325; } +inline int shared_fn_326(int x) { return x + 326; } +inline int shared_fn_327(int x) { return x + 327; } +inline int shared_fn_328(int x) { return x + 328; } +inline int shared_fn_329(int x) { return x + 329; } +inline int shared_fn_330(int x) { return x + 330; } +inline int shared_fn_331(int x) { return x + 331; } +inline int shared_fn_332(int x) { return x + 332; } +inline int shared_fn_333(int x) { return x + 333; } +inline int shared_fn_334(int x) { return x + 334; } +inline int shared_fn_335(int x) { return x + 335; } +inline int shared_fn_336(int x) { return x + 336; } +inline int shared_fn_337(int x) { return x + 337; } +inline int shared_fn_338(int x) { return x + 338; } +inline int shared_fn_339(int x) { return x + 339; } +inline int shared_fn_340(int x) { return x + 340; } +inline int shared_fn_341(int x) { return x + 341; } +inline int shared_fn_342(int x) { return x + 342; } +inline int shared_fn_343(int x) { return x + 343; } +inline int shared_fn_344(int x) { return x + 344; } +inline int shared_fn_345(int x) { return x + 345; } +inline int shared_fn_346(int x) { return x + 346; } +inline int shared_fn_347(int x) { return x + 347; } +inline int shared_fn_348(int x) { return x + 348; } +inline int shared_fn_349(int x) { return x + 349; } +inline int shared_fn_350(int x) { return x + 350; } +inline int shared_fn_351(int x) { return x + 351; } +inline int shared_fn_352(int x) { return x + 352; } +inline int shared_fn_353(int x) { return x + 353; } +inline int shared_fn_354(int x) { return x + 354; } +inline int shared_fn_355(int x) { return x + 355; } +inline int shared_fn_356(int x) { return x + 356; } +inline int shared_fn_357(int x) { return x + 357; } +inline int shared_fn_358(int x) { return x + 358; } +inline int shared_fn_359(int x) { return x + 359; } +inline int shared_fn_360(int x) { return x + 360; } +inline int shared_fn_361(int x) { return x + 361; } +inline int shared_fn_362(int x) { return x + 362; } +inline int shared_fn_363(int x) { return x + 363; } +inline int shared_fn_364(int x) { return x + 364; } +inline int shared_fn_365(int x) { return x + 365; } +inline int shared_fn_366(int x) { return x + 366; } +inline int shared_fn_367(int x) { return x + 367; } +inline int shared_fn_368(int x) { return x + 368; } +inline int shared_fn_369(int x) { return x + 369; } +inline int shared_fn_370(int x) { return x + 370; } +inline int shared_fn_371(int x) { return x + 371; } +inline int shared_fn_372(int x) { return x + 372; } +inline int shared_fn_373(int x) { return x + 373; } +inline int shared_fn_374(int x) { return x + 374; } +inline int shared_fn_375(int x) { return x + 375; } +inline int shared_fn_376(int x) { return x + 376; } +inline int shared_fn_377(int x) { return x + 377; } +inline int shared_fn_378(int x) { return x + 378; } +inline int shared_fn_379(int x) { return x + 379; } +inline int shared_fn_380(int x) { return x + 380; } +inline int shared_fn_381(int x) { return x + 381; } +inline int shared_fn_382(int x) { return x + 382; } +inline int shared_fn_383(int x) { return x + 383; } +inline int shared_fn_384(int x) { return x + 384; } +inline int shared_fn_385(int x) { return x + 385; } +inline int shared_fn_386(int x) { return x + 386; } +inline int shared_fn_387(int x) { return x + 387; } +inline int shared_fn_388(int x) { return x + 388; } +inline int shared_fn_389(int x) { return x + 389; } +inline int shared_fn_390(int x) { return x + 390; } +inline int shared_fn_391(int x) { return x + 391; } +inline int shared_fn_392(int x) { return x + 392; } +inline int shared_fn_393(int x) { return x + 393; } +inline int shared_fn_394(int x) { return x + 394; } +inline int shared_fn_395(int x) { return x + 395; } +inline int shared_fn_396(int x) { return x + 396; } +inline int shared_fn_397(int x) { return x + 397; } +inline int shared_fn_398(int x) { return x + 398; } +inline int shared_fn_399(int x) { return x + 399; } +#endif diff --git a/dedup-test/use.cpp b/dedup-test/use.cpp new file mode 100644 index 0000000000000..cc00041ff4cc4 --- /dev/null +++ b/dedup-test/use.cpp @@ -0,0 +1,3 @@ +#include "a.h" +#include "b.h" +int main() { return a_entry(1) + b_entry(2); } diff --git a/dedup-test/use_err.cpp b/dedup-test/use_err.cpp new file mode 100644 index 0000000000000..ea949c54d8aff --- /dev/null +++ b/dedup-test/use_err.cpp @@ -0,0 +1,7 @@ +#include "a.h" +#include "b.h" +int main() { + int x = a_entry("wrong"); // error -> forces resolving A's shared.h location + int y = b_entry("wrong"); // error -> forces resolving B's shared.h location + return x + y; +} _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
