This is an archive of the discontinued LLVM Phabricator instance.

Differential D43624

Change DEBUG() macro to LLVM_DEBUG()
ClosedPublic

Authored by Nicola on Feb 22 2018, 8:29 AM.

Details

Reviewers
zturner
javed.absar
andreadb
Commits
rGd34e60ca8532: Rename DEBUG macro to LLVM_DEBUG.
rL332240: Rename DEBUG macro to LLVM_DEBUG.
Summary

The DEBUG() macro is too generic so it might clash with other projects.
I noticed in include/llvm/DebugInfo/PDB/DIA/DIASupport.h a comment expressing interest in changing DEBUG() to LLVM_DEBUG() so I decided to give it a go.

This is the command I used to do the replacement:
git grep -l 'DEBUG' | xargs sed -i 's/\bDEBUG\s\?(/LLVM_DEBUG(/g'

Then I manually adjusted the DEBUG macro push/pop uses in APInt.cpp and DIASupport.h
Also, formatted the patch with git diff -U0 master | ../clang/tools/clang-format/clang-format-diff.py -i -p1 -style LLVM

Diff Detail

Event Timeline

Nicola created this revision.Feb 22 2018, 8:29 AM
Herald added subscribers: niosHD, sabuasal, apazos and 27 others. · View Herald TranscriptFeb 22 2018, 8:29 AM
1ace added a subscriber: 1ace.Feb 23 2018, 6:08 AM
PFerreira added a subscriber: PFerreira.Feb 27 2018, 1:34 AM
sbc100 added inline comments.Feb 27 2018, 3:42 PM
lib/MC/WasmObjectWriter.cpp
950

Maybe you want to git clang-format this to avoid introducing lines that are more than 80 cols?

sanjoy removed a subscriber: sanjoy.Feb 28 2018, 9:44 PM
Nicola updated this revision to Diff 136490.EditedMar 1 2018, 3:30 AM
Nicola edited the summary of this revision. (Show Details)

Reformatted the patch with clang-format-diff. Also rebased against latest LLVM master.

Nicola added a comment.Mar 8 2018, 2:33 AM

Ping

Nicola added a comment.Mar 15 2018, 8:30 AM

Ping ping?
clang is also using the DEBUG() macro and other projects might be doing the same. Any suggestion on how to proceed?

zturner accepted this revision.Mar 15 2018, 9:46 AM

Sorry for dragging my feet on reviewing this. I know it's a pain to keep large patches like this properly rebased. LGTM, I think this review has been up for enough time that I don't think anyone else is going to have any objections.

This revision is now accepted and ready to land.Mar 15 2018, 9:46 AM
Nicola updated this revision to Diff 138707.Mar 16 2018, 8:15 AM

Updated the patch to trunk@327699. I don't have commit rights so I cannot submit it, can you do it?

Should I open a review to change the DEBUG() macro in clang too? They use the LLVM one, so not having it will introduce build breaks. The patch for them should be quite small.

Herald added a subscriber: gbedwell. · View Herald TranscriptMar 16 2018, 8:15 AM
kuhar added a comment.Mar 16 2018, 8:39 AM
In D43624#1040196, @Nicola wrote:

Updated the patch to trunk@327699. I don't have commit rights so I cannot submit it, can you do it?

Should I open a review to change the DEBUG() macro in clang too? They use the LLVM one, so not having it will introduce build breaks. The patch for them should be quite small.

Note that there are much more (sub)projects within LLVM that use the DEBUG macro the patch shouldn't break. There are also countless downstream projects that will be affected and some other people will have to refactor them.

The DEBUG() macro is too generic so it might clash with other projects.

I understand the argument and agree in general, but are there some known problems with such clashes? I think this patch is going to cause quite a hassle to many users and I would like to understand the motivation better. Maybe it would be a better idea to explain the situation in more detail and post it as an RFC on llvm-dev.

Have you thought of leaving the old DEBUG macro around and making it an alias for the new LLVM_DEBUG? The old macro can be considered deprecated for some time before it gets completely removed, but this way the could give users some time to transition instead of breaking everything at once.

include/llvm/Support/Debug.h
15

I think this formatting should be fixed manually

Nicola added a comment.Mar 16 2018, 9:02 AM
In D43624#1040234, @kuhar wrote:
In D43624#1040196, @Nicola wrote:

Updated the patch to trunk@327699. I don't have commit rights so I cannot submit it, can you do it?

Should I open a review to change the DEBUG() macro in clang too? They use the LLVM one, so not having it will introduce build breaks. The patch for them should be quite small.

Note that there are much more (sub)projects within LLVM that use the DEBUG macro the patch shouldn't break. There are also countless downstream projects that will be affected and some other people will have to refactor them.

I understand the concern, that's why I checked the "main" projects: libcxx, lld, compiler-rt and lldb and none of them use the macro. clang is the only one that does (as far as I can tell)
Which other projects should I be checking?

The DEBUG() macro is too generic so it might clash with other projects.

I understand the argument and agree in general, but are there some known problems with such clashes? I think this patch is going to cause quite a hassle to many users and I would like to understand the motivation better. Maybe it would be a better idea to explain the situation in more detail and post it as an RFC on llvm-dev.

There are (were, at least?) clashes with other open source projects, such as MESA: https://lists.freedesktop.org/archives/mesa-dev/2016-July/124111.html and they ended up renaming DEBUG into MESA_DEBUG to avoid clashing with LLVM.
Thanks for pointing out about the RFC, I didn't think about it. I'll write up a post for llvm-dev in the coming days.

Have you thought of leaving the old DEBUG macro around and making it an alias for the new LLVM_DEBUG? The old macro can be considered deprecated for some time before it gets completely removed, but this way the could give users some time to transition instead of breaking everything at once.

I did think about leaving the old DEBUG macro around, that would make things easier on the breakage side. The issue is that we would need a way to deprecate the macro so that people stop using it and switch to the new one.
We could have a transition period in which we have both macros, but the "old" DEBUG macro should eventually be removed.

kuhar added a comment.Mar 16 2018, 9:31 AM
In D43624#1040260, @Nicola wrote:

I understand the concern, that's why I checked the "main" projects: libcxx, lld, compiler-rt and lldb and none of them use the macro. clang is the only one that does (as far as I can tell)
Which other projects should I be checking?

From the top of my head definitely Polly uses it. I'd make sure by cloning the git monorepo and doing a quick grep over it.

There are (were, at least?) clashes with other open source projects, such as MESA: https://lists.freedesktop.org/archives/mesa-dev/2016-July/124111.html and they ended up renaming DEBUG into MESA_DEBUG to avoid clashing with LLVM.

I see, thank you for the link.

I did think about leaving the old DEBUG macro around, that would make things easier on the breakage side. The issue is that we would need a way to deprecate the macro so that people stop using it and switch to the new one.
We could have a transition period in which we have both macros, but the "old" DEBUG macro should eventually be removed.

Well, worst case we could just announce it deprecated on the mailing list.

nhaehnle removed a subscriber: nhaehnle.Mar 17 2018, 5:26 AM
bcain added a subscriber: bcain.Mar 23 2018, 1:54 PM
dmgreen added a subscriber: dmgreen.Mar 24 2018, 10:45 AM
Nicola updated this revision to Diff 139809.Mar 26 2018, 9:50 AM

Rebased up to trunk@328503. Addressed comments about formatting on Debug.h (comment formatting is now fixed up manually)
This is still mostly with the commands I posted earlier (aside of Debug.h, DIASupport.h and APInt.cpp).

I kept the old DEBUG() macro around for a short transitional period. I'll open reviews with clang and Polly soon to remove the remaining DEBUG macro uses. Then I'll get a new review started for the final removal.

Regression tests passed on my side, but I don't have commit rights to submit the patch.
Are there any more concerns that need addressing? Otherwise I'm OK with it being submitted anytime.

sabuasal removed a subscriber: sabuasal.Mar 26 2018, 2:14 PM
Meinersbur added a subscriber: Meinersbur.Mar 27 2018, 8:42 AM
In D43624#1040281, @kuhar wrote:
In D43624#1040260, @Nicola wrote:

I understand the concern, that's why I checked the "main" projects: libcxx, lld, compiler-rt and lldb and none of them use the macro. clang is the only one that does (as far as I can tell)
Which other projects should I be checking?

From the top of my head definitely Polly uses it. I'd make sure by cloning the git monorepo and doing a quick grep over it.

I do confirm that we are using DEBUG(dbgs() << ./..) in Polly.

Nicola added a comment.Mar 28 2018, 3:47 AM

Submitted separate reviews for the other projects that use the macro:
clang: https://reviews.llvm.org/D44975
clang-tools-extra: https://reviews.llvm.org/D44976
lld: https://reviews.llvm.org/D44977
Polly: https://reviews.llvm.org/D44978

Updating the LLVM patch up to r328689 now

Nicola updated this revision to Diff 140062.Mar 28 2018, 3:48 AM
Closed by commit rL332240: Rename DEBUG macro to LLVM_DEBUG. (authored by nzaghen). · Explain WhyMay 14 2018, 5:58 AM
This revision was automatically updated to reflect the committed changes.
Herald added a reviewer: javed.absar. · View Herald TranscriptMay 14 2018, 5:58 AM
Herald added a reviewer: andreadb. · View Herald Transcript
Herald added subscribers: mgrang, edward-jones, george.burgess.iv, zzheng. · View Herald Transcript

Large Diff

This large diff affects 492 files. Files without inline comments have been collapsed. Expand All Files

Revision Contents

PathSize
docs/
16 lines
CommandGuide/
2 lines
6 lines
18 lines
include/
llvm/
Analysis/
47 lines
46 lines
2 lines
10 lines
CodeGen/
GlobalISel/
8 lines
DebugInfo/
PDB/
DIA/
10 lines
ExecutionEngine/
Orc/
89 lines
83 lines
Support/
16 lines
251 lines
16 lines
Transforms/
InstCombine/
5 lines
Utils/
2 lines
lib/
Analysis/
80 lines
18 lines
5 lines
5 lines
35 lines
51 lines
2 lines
8 lines
487 lines
17 lines
10 lines
14 lines
19 lines
55 lines
198 lines
4 lines
15 lines
12 lines
25 lines
13 lines
100 lines
CodeGen/
152 lines
2 lines
AsmPrinter/
5 lines
16 lines
4 lines
4 lines
8 lines
57 lines
41 lines
8 lines
4 lines
135 lines
18 lines
28 lines
2 lines
35 lines
97 lines
14 lines
31 lines
22 lines
GlobalISel/
6 lines
2 lines
8 lines
10 lines
18 lines
33 lines
18 lines
44 lines
22 lines
2 lines
4 lines
53 lines
83 lines
6 lines
12 lines
42 lines
38 lines
45 lines
16 lines
2 lines
36 lines
17 lines
83 lines
14 lines
161 lines
17 lines
51 lines
34 lines
6 lines
45 lines
12 lines
69 lines
2 lines
2 lines
362 lines
34 lines
54 lines
20 lines
23 lines
49 lines
44 lines
16 lines
24 lines
14 lines
12 lines
13 lines
95 lines
196 lines
22 lines
16 lines
25 lines
2 lines
196 lines
23 lines
14 lines
2 lines
48 lines
16 lines
28 lines
41 lines
16 lines
SelectionDAG/
84 lines
8 lines
2 lines
77 lines
12 lines
16 lines
17 lines
17 lines
32 lines
36 lines
142 lines
12 lines
10 lines
65 lines
185 lines
2 lines
50 lines
4 lines
8 lines
170 lines
72 lines
8 lines
22 lines
29 lines
20 lines
3 lines
47 lines
17 lines
31 lines
ExecutionEngine/
13 lines
Interpreter/
10 lines
OProfileJIT/
24 lines
9 lines
RuntimeDyld/
84 lines
7 lines
87 lines
16 lines
Targets/
45 lines
63 lines
13 lines
44 lines
2 lines
12 lines
12 lines
2 lines
IR/
4 lines
19 lines
8 lines
21 lines
7 lines
LTO/
6 lines
MC/
11 lines
54 lines
Object/
4 lines
ProfileData/
Coverage/
17 lines
2 lines
Support/
72 lines
28 lines
6 lines
124 lines
6 lines
6 lines
Target/
AArch64/
25 lines
60 lines
6 lines
40 lines
29 lines
30 lines
91 lines
25 lines
12 lines
43 lines
18 lines
141 lines
107 lines
79 lines
24 lines
64 lines
8 lines
12 lines
8 lines
AMDGPU/
4 lines
81 lines
392 lines
2 lines
47 lines
11 lines
10 lines
247 lines
27 lines
65 lines
51 lines
77 lines
6 lines
15 lines
37 lines
16 lines
6 lines
2 lines
34 lines
2 lines
16 lines
37 lines
3 lines
6 lines
99 lines
23 lines
7 lines
6 lines
6 lines
5 lines
ARC/
16 lines
62 lines
4 lines
8 lines
32 lines
Disassembler/
24 lines
ARM/
19 lines
4 lines
8 lines
111 lines
68 lines
13 lines
45 lines
4 lines
8 lines
AsmParser/
9 lines
22 lines
12 lines
AVR/
2 lines
AsmParser/
4 lines
BPF/
31 lines
2 lines
Hexagon/
AsmParser/
18 lines
13 lines
10 lines
10 lines
87 lines
26 lines
55 lines
2 lines
40 lines
44 lines
55 lines
18 lines
21 lines
14 lines
50 lines
10 lines
42 lines
26 lines
146 lines
13 lines
61 lines
30 lines
2 lines
26 lines
19 lines
39 lines
17 lines
MCTargetDesc/
33 lines
30 lines
28 lines
30 lines
13 lines
6 lines
Lanai/
2 lines
4 lines
MSP430/
12 lines
6 lines
Mips/
AsmParser/
28 lines
Disassembler/
34 lines
MCTargetDesc/
14 lines
6 lines
6 lines
4 lines
96 lines
53 lines
2 lines
2 lines
16 lines
16 lines
8 lines
3 lines
3 lines
6 lines
NVPTX/
12 lines
2 lines
Nios2/
2 lines
PowerPC/
18 lines
116 lines
28 lines
46 lines
8 lines
146 lines
18 lines
21 lines
8 lines
120 lines
8 lines
39 lines
2 lines
12 lines
133 lines
RISCV/
Disassembler/
7 lines
2 lines
8 lines
SystemZ/
35 lines
14 lines
40 lines
WebAssembly/
2 lines
4 lines
6 lines
6 lines
10 lines
6 lines
13 lines
2 lines
6 lines
6 lines
2 lines
2 lines
16 lines
16 lines
24 lines
2 lines
2 lines
8 lines
X86/
Disassembler/
2 lines
12 lines
10 lines
4 lines
36 lines
57 lines
25 lines
4 lines
32 lines
7 lines
2 lines
6 lines
8 lines
12 lines
XCore/
16 lines
Transforms/
AggressiveInstCombine/
7 lines
Coroutines/
30 lines
6 lines
IPO/
32 lines
7 lines
40 lines
4 lines
9 lines
116 lines
37 lines
56 lines
6 lines
2 lines
168 lines
69 lines
InstCombine/
4 lines
18 lines
6 lines
6 lines
11 lines
6 lines
39 lines
Instrumentation/
28 lines
4 lines
14 lines
8 lines
6 lines
28 lines
4 lines
66 lines
58 lines
35 lines
2 lines
ObjCARC/
10 lines
37 lines
13 lines
156 lines
40 lines
Scalar/
25 lines
36 lines
2 lines
6 lines
77 lines
2 lines
79 lines
38 lines
13 lines
116 lines
14 lines
27 lines
13 lines
51 lines
40 lines
12 lines
83 lines
15 lines
10 lines
25 lines
39 lines
24 lines
153 lines
37 lines
80 lines
119 lines
21 lines
6 lines
225 lines
68 lines
52 lines
72 lines
26 lines
89 lines
12 lines
232 lines
8 lines
57 lines
21 lines
64 lines
188 lines
37 lines
10 lines
55 lines
4 lines
14 lines
6 lines
Utils/
6 lines
14 lines
2 lines
134 lines
4 lines
2 lines
22 lines
32 lines
23 lines
54 lines
25 lines
30 lines
35 lines
37 lines
19 lines
2 lines
82 lines
27 lines
12 lines
4 lines
Vectorize/
32 lines
304 lines
282 lines
14 lines
tools/
bugpoint/
6 lines
8 lines
53 lines
lli/
4 lines
llvm-dwarfdump/
15 lines
verify-uselistorder/
42 lines
unittests/
IR/
12 lines
12 lines
utils/
TableGen/
4 lines
4 lines
48 lines
89 lines
149 lines
17 lines
15 lines
143 lines
72 lines
4 lines
9 lines
6 lines
13 lines

Diff 136490

docs/Bugpoint.rst

docs/CommandGuide/opt.rst

docs/CommandLine.rst

docs/ProgrammersManual.rst

include/llvm/Analysis/BlockFrequencyInfoImpl.h

include/llvm/Analysis/CGSCCPassManager.h

include/llvm/Analysis/RegionInfoImpl.h

include/llvm/Analysis/SparsePropagation.h

include/llvm/CodeGen/GlobalISel/LegalizationArtifactCombiner.h

include/llvm/DebugInfo/PDB/DIA/DIASupport.h

include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h

include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h

include/llvm/Support/Debug.h

//===- llvm/Support/Debug.h - Easy way to add debug output ------*- C++ -*-===// //===- llvm/Support/Debug.h - Easy way to add debug output ------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a handy way of adding debugging information to your // This file implements a handy way of adding debugging information to your
// code, without it being enabled all of the time, and without having to add // code, without it being enabled all of the time, and without having to add
// command line options to enable it. // command line options to enable it.
// //
// In particular, just wrap your code with the DEBUG() macro, and it will be // In particular, just wrap your code with the LLVM_DEBUG() macro, and it will
// be
kuharUnsubmitted
Not Done
ReplyInline Actions

I think this formatting should be fixed manually

kuhar: I think this formatting should be fixed manually
// enabled automatically if you specify '-debug' on the command-line. // enabled automatically if you specify '-debug' on the command-line.
// DEBUG() requires the DEBUG_TYPE macro to be defined. Set it to "foo" specify // LLVM_DEBUG() requires the DEBUG_TYPE macro to be defined. Set it to "foo"
// specify
// that your debug code belongs to class "foo". Be careful that you only do // that your debug code belongs to class "foo". Be careful that you only do
// this after including Debug.h and not around any #include of headers. Headers // this after including Debug.h and not around any #include of headers. Headers
// should define and undef the macro acround the code that needs to use the // should define and undef the macro acround the code that needs to use the
// DEBUG() macro. Then, on the command line, you can specify '-debug-only=foo' // LLVM_DEBUG() macro. Then, on the command line, you can specify
// '-debug-only=foo'
// to enable JUST the debug information for the foo class. // to enable JUST the debug information for the foo class.
// //
// When compiling without assertions, the -debug-* options and all code in // When compiling without assertions, the -debug-* options and all code in
// DEBUG() statements disappears, so it does not affect the runtime of the code. // LLVM_DEBUG() statements disappears, so it does not affect the runtime of the
// code.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_SUPPORT_DEBUG_H #ifndef LLVM_SUPPORT_DEBUG_H
#define LLVM_SUPPORT_DEBUG_H #define LLVM_SUPPORT_DEBUG_H
namespace llvm { namespace llvm {
Show All 24 Lines
/// like: dbgs() << "foo" << "bar"; /// like: dbgs() << "foo" << "bar";
raw_ostream &dbgs(); raw_ostream &dbgs();
// DEBUG macro - This macro should be used by passes to emit debug information. // DEBUG macro - This macro should be used by passes to emit debug information.
// In the '-debug' option is specified on the commandline, and if this is a // In the '-debug' option is specified on the commandline, and if this is a
// debug build, then the code specified as the option to the macro will be // debug build, then the code specified as the option to the macro will be
// executed. Otherwise it will not be. Example: // executed. Otherwise it will not be. Example:
// //
// DEBUG(dbgs() << "Bitset contains: " << Bitset << "\n"); // LLVM_DEBUG(dbgs() << "Bitset contains: " << Bitset << "\n");
// //
#define DEBUG(X) DEBUG_WITH_TYPE(DEBUG_TYPE, X) #define LLVM_DEBUG(X) DEBUG_WITH_TYPE(DEBUG_TYPE, X)
} // end namespace llvm } // end namespace llvm
#endif // LLVM_SUPPORT_DEBUG_H #endif // LLVM_SUPPORT_DEBUG_H
Context not available.

include/llvm/Support/GenericDomTreeConstruction.h

include/llvm/Support/UnicodeCharRanges.h

include/llvm/Transforms/InstCombine/InstCombineWorklist.h

include/llvm/Transforms/Utils/SSAUpdaterImpl.h

lib/Analysis/BlockFrequencyInfoImpl.cpp

lib/Analysis/BranchProbabilityInfo.cpp

lib/Analysis/CFLAndersAliasAnalysis.cpp

lib/Analysis/CFLSteensAliasAnalysis.cpp

lib/Analysis/CGSCCPassManager.cpp

lib/Analysis/CallGraphSCCPass.cpp

lib/Analysis/CodeMetrics.cpp

lib/Analysis/DemandedBits.cpp

lib/Analysis/DependenceAnalysis.cpp

lib/Analysis/IVUsers.cpp

lib/Analysis/IndirectCallPromotionAnalysis.cpp

lib/Analysis/InlineCost.cpp

lib/Analysis/LazyCallGraph.cpp

lib/Analysis/LazyValueInfo.cpp

lib/Analysis/LoopAccessAnalysis.cpp

lib/Analysis/LoopPass.cpp

lib/Analysis/MemoryBuiltins.cpp

lib/Analysis/MemoryDependenceAnalysis.cpp

lib/Analysis/MemorySSA.cpp

lib/Analysis/RegionPass.cpp

lib/Analysis/ScalarEvolution.cpp

lib/CodeGen/AggressiveAntiDepBreaker.cpp

lib/CodeGen/AllocationOrder.cpp

lib/CodeGen/AsmPrinter/DIE.cpp

lib/CodeGen/AsmPrinter/DIEHash.cpp

lib/CodeGen/AsmPrinter/DbgValueHistoryCalculator.cpp

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

lib/CodeGen/AtomicExpandPass.cpp

lib/CodeGen/BranchFolding.cpp

lib/CodeGen/BranchRelaxation.cpp

lib/CodeGen/BreakFalseDeps.cpp

lib/CodeGen/CalcSpillWeights.cpp

lib/CodeGen/CodeGenPrepare.cpp

lib/CodeGen/CriticalAntiDepBreaker.cpp

lib/CodeGen/DFAPacketizer.cpp

lib/CodeGen/DeadMachineInstructionElim.cpp

lib/CodeGen/DetectDeadLanes.cpp

lib/CodeGen/EarlyIfConversion.cpp

lib/CodeGen/ExecutionDomainFix.cpp

lib/CodeGen/ExpandPostRAPseudos.cpp

lib/CodeGen/FaultMaps.cpp

lib/CodeGen/GlobalISel/Combiner.cpp

lib/CodeGen/GlobalISel/IRTranslator.cpp

lib/CodeGen/GlobalISel/InstructionSelect.cpp

lib/CodeGen/GlobalISel/Legalizer.cpp

lib/CodeGen/GlobalISel/LegalizerHelper.cpp

lib/CodeGen/GlobalISel/LegalizerInfo.cpp

lib/CodeGen/GlobalISel/Localizer.cpp

lib/CodeGen/GlobalISel/RegBankSelect.cpp

lib/CodeGen/GlobalISel/RegisterBankInfo.cpp

lib/CodeGen/GlobalISel/Utils.cpp

lib/CodeGen/GlobalMerge.cpp

lib/CodeGen/IfConversion.cpp

lib/CodeGen/InlineSpiller.cpp

lib/CodeGen/InterleavedAccessPass.cpp

lib/CodeGen/LazyMachineBlockFrequencyInfo.cpp

lib/CodeGen/LiveDebugValues.cpp

lib/CodeGen/LiveDebugVariables.cpp

lib/CodeGen/LiveIntervals.cpp

lib/CodeGen/LiveRangeEdit.cpp

lib/CodeGen/LiveRangeShrink.cpp

lib/CodeGen/LiveRegMatrix.cpp

lib/CodeGen/LocalStackSlotAllocation.cpp

lib/CodeGen/MIRCanonicalizerPass.cpp

lib/CodeGen/MachineBasicBlock.cpp

lib/CodeGen/MachineBlockPlacement.cpp

lib/CodeGen/MachineCSE.cpp

lib/CodeGen/MachineCombiner.cpp

lib/CodeGen/MachineCopyPropagation.cpp

lib/CodeGen/MachineFrameInfo.cpp

lib/CodeGen/MachineLICM.cpp

lib/CodeGen/MachineOutliner.cpp

lib/CodeGen/MachinePipeliner.cpp

lib/CodeGen/MachineRegionInfo.cpp

lib/CodeGen/MachineSSAUpdater.cpp

lib/CodeGen/MachineScheduler.cpp

lib/CodeGen/MachineSink.cpp

lib/CodeGen/MachineTraceMetrics.cpp

lib/CodeGen/MacroFusion.cpp

lib/CodeGen/PHIElimination.cpp

lib/CodeGen/PeepholeOptimizer.cpp

lib/CodeGen/PostRASchedulerList.cpp

lib/CodeGen/ProcessImplicitDefs.cpp

lib/CodeGen/PrologEpilogInserter.cpp

lib/CodeGen/ReachingDefAnalysis.cpp

lib/CodeGen/RegAllocBase.cpp

lib/CodeGen/RegAllocBasic.cpp

lib/CodeGen/RegAllocFast.cpp

lib/CodeGen/RegAllocGreedy.cpp

lib/CodeGen/RegAllocPBQP.cpp

lib/CodeGen/RegUsageInfoCollector.cpp

lib/CodeGen/RegUsageInfoPropagate.cpp

lib/CodeGen/RegisterClassInfo.cpp

lib/CodeGen/RegisterCoalescer.cpp

lib/CodeGen/RegisterScavenging.cpp

lib/CodeGen/RenameIndependentSubregs.cpp

lib/CodeGen/ResetMachineFunctionPass.cpp

lib/CodeGen/SafeStack.cpp

lib/CodeGen/SafeStackColoring.cpp

lib/CodeGen/SafeStackLayout.cpp

lib/CodeGen/ScheduleDAGInstrs.cpp

lib/CodeGen/ScoreboardHazardRecognizer.cpp

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

lib/CodeGen/SelectionDAG/FastISel.cpp

lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp

lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp

lib/CodeGen/SelectionDAG/LegalizeTypes.cpp

lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp

lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp

lib/CodeGen/SelectionDAG/ScheduleDAGFast.cpp

lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp

lib/CodeGen/SelectionDAG/ScheduleDAGVLIW.cpp

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp

lib/CodeGen/ShrinkWrap.cpp

lib/CodeGen/SjLjEHPrepare.cpp

lib/CodeGen/SlotIndexes.cpp

lib/CodeGen/SplitKit.cpp

lib/CodeGen/StackColoring.cpp

lib/CodeGen/StackMapLivenessAnalysis.cpp

lib/CodeGen/StackMaps.cpp

lib/CodeGen/StackSlotColoring.cpp

lib/CodeGen/TailDuplicator.cpp

lib/CodeGen/TargetRegisterInfo.cpp

lib/CodeGen/TwoAddressInstructionPass.cpp

lib/CodeGen/VirtRegMap.cpp

lib/CodeGen/WinEHPrepare.cpp

lib/ExecutionEngine/ExecutionEngine.cpp

lib/ExecutionEngine/Interpreter/Execution.cpp

lib/ExecutionEngine/OProfileJIT/OProfileJITEventListener.cpp

lib/ExecutionEngine/OProfileJIT/OProfileWrapper.cpp

lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFI386.h

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFThumb.h

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFX86_64.h

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldELFMips.cpp

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOAArch64.h

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOARM.h

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOI386.h

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOX86_64.h

lib/IR/ConstantsContext.h

lib/IR/Core.cpp

lib/IR/Pass.cpp

lib/IR/SafepointIRVerifier.cpp

lib/IR/ValueSymbolTable.cpp

lib/LTO/ThinLTOCodeGenerator.cpp

lib/MC/MachObjectWriter.cpp

lib/MC/WasmObjectWriter.cpp

Show All 12 Lines
// Write out a section header and a patchable section size field. // Write out a section header and a patchable section size field.
void WasmObjectWriter::startSection(SectionBookkeeping &Section, void WasmObjectWriter::startSection(SectionBookkeeping &Section,
unsigned SectionId, unsigned SectionId,
const char *Name) { const char *Name) {
assert((Name != nullptr) == (SectionId == wasm::WASM_SEC_CUSTOM) && assert((Name != nullptr) == (SectionId == wasm::WASM_SEC_CUSTOM) &&
"Only custom sections can have names"); "Only custom sections can have names");
DEBUG(dbgs() << "startSection " << SectionId << ": " << Name << "\n"); LLVM_DEBUG(dbgs() << "startSection " << SectionId << ": " << Name << "\n");
encodeULEB128(SectionId, getStream()); encodeULEB128(SectionId, getStream());
Section.SizeOffset = getStream().tell(); Section.SizeOffset = getStream().tell();
// The section size. We don't know the size yet, so reserve enough space // The section size. We don't know the size yet, so reserve enough space
// for any 32-bit value; we'll patch it later. // for any 32-bit value; we'll patch it later.
encodeULEB128(UINT32_MAX, getStream()); encodeULEB128(UINT32_MAX, getStream());
Show All 9 Lines
// Now that the section is complete and we know how big it is, patch up the // Now that the section is complete and we know how big it is, patch up the
// section size field at the start of the section. // section size field at the start of the section.
void WasmObjectWriter::endSection(SectionBookkeeping &Section) { void WasmObjectWriter::endSection(SectionBookkeeping &Section) {
uint64_t Size = getStream().tell() - Section.ContentsOffset; uint64_t Size = getStream().tell() - Section.ContentsOffset;
if (uint32_t(Size) != Size) if (uint32_t(Size) != Size)
report_fatal_error("section size does not fit in a uint32_t"); report_fatal_error("section size does not fit in a uint32_t");
DEBUG(dbgs() << "endSection size=" << Size << "\n"); LLVM_DEBUG(dbgs() << "endSection size=" << Size << "\n");
// Write the final section size to the payload_len field, which follows // Write the final section size to the payload_len field, which follows
// the section id byte. // the section id byte.
uint8_t Buffer[16]; uint8_t Buffer[16];
unsigned SizeLen = encodeULEB128(Size, Buffer, 5); unsigned SizeLen = encodeULEB128(Size, Buffer, 5);
assert(SizeLen == 5); assert(SizeLen == 5);
getStream().pwrite((char *)Buffer, SizeLen, Section.SizeOffset); getStream().pwrite((char *)Buffer, SizeLen, Section.SizeOffset);
} }
Show All 24 Lines
SymA->setUsedInReloc(); SymA->setUsedInReloc();
assert(!IsPCRel); assert(!IsPCRel);
assert(SymA); assert(SymA);
unsigned Type = getRelocType(Target, Fixup); unsigned Type = getRelocType(Target, Fixup);
WasmRelocationEntry Rec(FixupOffset, SymA, C, Type, &FixupSection); WasmRelocationEntry Rec(FixupOffset, SymA, C, Type, &FixupSection);
DEBUG(dbgs() << "WasmReloc: " << Rec << "\n"); LLVM_DEBUG(dbgs() << "WasmReloc: " << Rec << "\n");
// Relocation other than R_WEBASSEMBLY_TYPE_INDEX_LEB are currently required // Relocation other than R_WEBASSEMBLY_TYPE_INDEX_LEB are currently required
// to be against a named symbol. // to be against a named symbol.
// TODO(sbc): Add support for relocations against unnamed temporaries such // TODO(sbc): Add support for relocations against unnamed temporaries such
// as those generated by llvm's `blockaddress`. // as those generated by llvm's `blockaddress`.
// See: test/MC/WebAssembly/blockaddress.ll // See: test/MC/WebAssembly/blockaddress.ll
if (SymA->getName().empty() && Type != wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB) if (SymA->getName().empty() && Type != wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB)
report_fatal_error("relocations against un-named temporaries are not yet " report_fatal_error("relocations against un-named temporaries are not yet "
Show All 24 Lines
} }
default: default:
llvm_unreachable("invalid relocation type"); llvm_unreachable("invalid relocation type");
} }
} }
static void addData(SmallVectorImpl<char> &DataBytes, static void addData(SmallVectorImpl<char> &DataBytes,
MCSectionWasm &DataSection) { MCSectionWasm &DataSection) {
DEBUG(errs() << "addData: " << DataSection.getSectionName() << "\n"); LLVM_DEBUG(errs() << "addData: " << DataSection.getSectionName() << "\n");
DataBytes.resize(alignTo(DataBytes.size(), DataSection.getAlignment())); DataBytes.resize(alignTo(DataBytes.size(), DataSection.getAlignment()));
for (const MCFragment &Frag : DataSection) { for (const MCFragment &Frag : DataSection) {
if (Frag.hasInstructions()) if (Frag.hasInstructions())
report_fatal_error("only data supported in data sections"); report_fatal_error("only data supported in data sections");
if (auto *Align = dyn_cast<MCAlignFragment>(&Frag)) { if (auto *Align = dyn_cast<MCAlignFragment>(&Frag)) {
Show All 14 Lines
} else { } else {
const auto &DataFrag = cast<MCDataFragment>(Frag); const auto &DataFrag = cast<MCDataFragment>(Frag);
const SmallVectorImpl<char> &Contents = DataFrag.getContents(); const SmallVectorImpl<char> &Contents = DataFrag.getContents();
DataBytes.insert(DataBytes.end(), Contents.begin(), Contents.end()); DataBytes.insert(DataBytes.end(), Contents.begin(), Contents.end());
} }
} }
DEBUG(dbgs() << "addData -> " << DataBytes.size() << "\n"); LLVM_DEBUG(dbgs() << "addData -> " << DataBytes.size() << "\n");
} }
uint32_t uint32_t
WasmObjectWriter::getRelocationIndexValue(const WasmRelocationEntry &RelEntry) { WasmObjectWriter::getRelocationIndexValue(const WasmRelocationEntry &RelEntry) {
if (RelEntry.Type == wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB) { if (RelEntry.Type == wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB) {
if (!TypeIndices.count(RelEntry.Symbol)) if (!TypeIndices.count(RelEntry.Symbol))
report_fatal_error("symbol not found in type index space: " + report_fatal_error("symbol not found in type index space: " +
RelEntry.Symbol->getName()); RelEntry.Symbol->getName());
Show All 11 Lines
void WasmObjectWriter::applyRelocations( void WasmObjectWriter::applyRelocations(
ArrayRef<WasmRelocationEntry> Relocations, uint64_t ContentsOffset) { ArrayRef<WasmRelocationEntry> Relocations, uint64_t ContentsOffset) {
raw_pwrite_stream &Stream = getStream(); raw_pwrite_stream &Stream = getStream();
for (const WasmRelocationEntry &RelEntry : Relocations) { for (const WasmRelocationEntry &RelEntry : Relocations) {
uint64_t Offset = ContentsOffset + uint64_t Offset = ContentsOffset +
RelEntry.FixupSection->getSectionOffset() + RelEntry.FixupSection->getSectionOffset() +
RelEntry.Offset; RelEntry.Offset;
DEBUG(dbgs() << "applyRelocation: " << RelEntry << "\n"); LLVM_DEBUG(dbgs() << "applyRelocation: " << RelEntry << "\n");
uint32_t Value = getProvisionalValue(RelEntry); uint32_t Value = getProvisionalValue(RelEntry);
switch (RelEntry.Type) { switch (RelEntry.Type) {
case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB: case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB: case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB: case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB: case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
WritePatchableLEB(Stream, Value, Offset); WritePatchableLEB(Stream, Value, Offset);
Show All 15 Lines
return TypeIndices[&Symbol]; return TypeIndices[&Symbol];
} }
uint32_t WasmObjectWriter::registerFunctionType(const MCSymbolWasm& Symbol) { uint32_t WasmObjectWriter::registerFunctionType(const MCSymbolWasm& Symbol) {
assert(Symbol.isFunction()); assert(Symbol.isFunction());
WasmFunctionType F; WasmFunctionType F;
const MCSymbolWasm* ResolvedSym = ResolveSymbol(Symbol); const MCSymbolWasm* ResolvedSym = ResolveSymbol(Symbol);
F.Returns = ResolvedSym->getReturns(); F.Returns = ResolvedSym->getReturns();
sbc100Unsubmitted
Not Done
ReplyInline Actions

Maybe you want to git clang-format this to avoid introducing lines that are more than 80 cols?

sbc100: Maybe you want to `git clang-format` this to avoid introducing lines that are more than 80 cols?
F.Params = ResolvedSym->getParams(); F.Params = ResolvedSym->getParams();
auto Pair = auto Pair =
FunctionTypeIndices.insert(std::make_pair(F, FunctionTypes.size())); FunctionTypeIndices.insert(std::make_pair(F, FunctionTypes.size()));
if (Pair.second) if (Pair.second)
FunctionTypes.push_back(F); FunctionTypes.push_back(F);
TypeIndices[&Symbol] = Pair.first->second; TypeIndices[&Symbol] = Pair.first->second;
DEBUG(dbgs() << "registerFunctionType: " << Symbol << " new:" << Pair.second << "\n"); LLVM_DEBUG(dbgs() << "registerFunctionType: " << Symbol
DEBUG(dbgs() << " -> type index: " << Pair.first->second << "\n"); << " new:" << Pair.second << "\n");
LLVM_DEBUG(dbgs() << " -> type index: " << Pair.first->second << "\n");
return Pair.first->second; return Pair.first->second;
} }
void WasmObjectWriter::writeObject(MCAssembler &Asm, void WasmObjectWriter::writeObject(MCAssembler &Asm,
const MCAsmLayout &Layout) { const MCAsmLayout &Layout) {
DEBUG(dbgs() << "WasmObjectWriter::writeObject\n"); LLVM_DEBUG(dbgs() << "WasmObjectWriter::writeObject\n");
MCContext &Ctx = Asm.getContext(); MCContext &Ctx = Asm.getContext();
// Collect information from the available symbols. // Collect information from the available symbols.
SmallVector<WasmFunction, 4> Functions; SmallVector<WasmFunction, 4> Functions;
SmallVector<uint32_t, 4> TableElems; SmallVector<uint32_t, 4> TableElems;
SmallVector<wasm::WasmImport, 4> Imports; SmallVector<wasm::WasmImport, 4> Imports;
SmallVector<wasm::WasmExport, 4> Exports; SmallVector<wasm::WasmExport, 4> Exports;
SmallVector<wasm::WasmSymbolInfo, 4> SymbolInfos; SmallVector<wasm::WasmSymbolInfo, 4> SymbolInfos;
Show All 24 Lines
// Populate WasmIndices and DataLocations for defined symbols. // Populate WasmIndices and DataLocations for defined symbols.
for (const MCSymbol &S : Asm.symbols()) { for (const MCSymbol &S : Asm.symbols()) {
// Ignore unnamed temporary symbols, which aren't ever exported, imported, // Ignore unnamed temporary symbols, which aren't ever exported, imported,
// or used in relocations. // or used in relocations.
if (S.isTemporary() && S.getName().empty()) if (S.isTemporary() && S.getName().empty())
continue; continue;
const auto &WS = static_cast<const MCSymbolWasm &>(S); const auto &WS = static_cast<const MCSymbolWasm &>(S);
DEBUG(dbgs() << "MCSymbol: '" << S << "'" LLVM_DEBUG(dbgs() << "MCSymbol: '" << S << "'"
<< " isDefined=" << S.isDefined() << " isDefined=" << S.isDefined() << " isExternal="
<< " isExternal=" << S.isExternal() << S.isExternal() << " isTemporary=" << S.isTemporary()
<< " isTemporary=" << S.isTemporary() << " isFunction=" << WS.isFunction() << " isWeak="
<< " isFunction=" << WS.isFunction() << WS.isWeak() << " isHidden=" << WS.isHidden()
<< " isWeak=" << WS.isWeak() << " isVariable=" << WS.isVariable() << "\n");
<< " isHidden=" << WS.isHidden()
<< " isVariable=" << WS.isVariable() << "\n");
if (WS.isVariable()) if (WS.isVariable())
continue; continue;
if (WS.isComdat() && !WS.isDefined()) if (WS.isComdat() && !WS.isDefined())
continue; continue;
if (WS.isFunction()) { if (WS.isFunction()) {
unsigned Index; unsigned Index;
Show All 19 Lines
Comdats[C->getName()].emplace_back( Comdats[C->getName()].emplace_back(
WasmComdatEntry{wasm::WASM_COMDAT_FUNCTION, Index}); WasmComdatEntry{wasm::WASM_COMDAT_FUNCTION, Index});
} }
} else { } else {
// An import; the index was assigned above. // An import; the index was assigned above.
Index = WasmIndices.find(&WS)->second; Index = WasmIndices.find(&WS)->second;
} }
DEBUG(dbgs() << " -> function index: " << Index << "\n"); LLVM_DEBUG(dbgs() << " -> function index: " << Index << "\n");
} else if (WS.isData()) { } else if (WS.isData()) {
if (WS.isTemporary() && !WS.getSize()) if (WS.isTemporary() && !WS.getSize())
continue; continue;
if (!WS.isDefined()) { if (!WS.isDefined()) {
DEBUG(dbgs() << " -> segment index: -1"); LLVM_DEBUG(dbgs() << " -> segment index: -1");
continue; continue;
} }
if (!WS.getSize()) if (!WS.getSize())
report_fatal_error("data symbols must have a size set with .size: " + report_fatal_error("data symbols must have a size set with .size: " +
WS.getName()); WS.getName());
int64_t Size = 0; int64_t Size = 0;
if (!WS.getSize()->evaluateAsAbsolute(Size, Layout)) if (!WS.getSize()->evaluateAsAbsolute(Size, Layout))
report_fatal_error(".size expression must be evaluatable"); report_fatal_error(".size expression must be evaluatable");
auto &DataSection = static_cast<MCSectionWasm &>(WS.getSection()); auto &DataSection = static_cast<MCSectionWasm &>(WS.getSection());
assert(DataSection.isWasmData()); assert(DataSection.isWasmData());
// For each data symbol, export it in the symtab as a reference to the // For each data symbol, export it in the symtab as a reference to the
// corresponding Wasm data segment. // corresponding Wasm data segment.
wasm::WasmDataReference Ref = wasm::WasmDataReference{ wasm::WasmDataReference Ref = wasm::WasmDataReference{
DataSection.getSegmentIndex(), DataSection.getSegmentIndex(),
static_cast<uint32_t>(Layout.getSymbolOffset(WS)), static_cast<uint32_t>(Layout.getSymbolOffset(WS)),
static_cast<uint32_t>(Size)}; static_cast<uint32_t>(Size)};
DataLocations[&WS] = Ref; DataLocations[&WS] = Ref;
DEBUG(dbgs() << " -> segment index: " << Ref.Segment); LLVM_DEBUG(dbgs() << " -> segment index: " << Ref.Segment);
} else { } else {
// A "true" Wasm global (currently just __stack_pointer) // A "true" Wasm global (currently just __stack_pointer)
if (WS.isDefined()) if (WS.isDefined())
report_fatal_error("don't yet support defined globals"); report_fatal_error("don't yet support defined globals");
// An import; the index was assigned above // An import; the index was assigned above
DEBUG(dbgs() << " -> global index: " << WasmIndices.find(&WS)->second LLVM_DEBUG(dbgs() << " -> global index: "
<< "\n"); << WasmIndices.find(&WS)->second << "\n");
} }
} }
// Populate WasmIndices and DataLocations for aliased symbols. We need to // Populate WasmIndices and DataLocations for aliased symbols. We need to
// process these in a separate pass because we need to have processed the // process these in a separate pass because we need to have processed the
// target of the alias before the alias itself and the symbols are not // target of the alias before the alias itself and the symbols are not
// necessarily ordered in this way. // necessarily ordered in this way.
for (const MCSymbol &S : Asm.symbols()) { for (const MCSymbol &S : Asm.symbols()) {
if (!S.isVariable()) if (!S.isVariable())
continue; continue;
assert(S.isDefined()); assert(S.isDefined());
// Find the target symbol of this weak alias and export that index // Find the target symbol of this weak alias and export that index
const auto &WS = static_cast<const MCSymbolWasm &>(S); const auto &WS = static_cast<const MCSymbolWasm &>(S);
const MCSymbolWasm *ResolvedSym = ResolveSymbol(WS); const MCSymbolWasm *ResolvedSym = ResolveSymbol(WS);
DEBUG(dbgs() << WS.getName() << ": weak alias of '" << *ResolvedSym << "'\n"); LLVM_DEBUG(dbgs() << WS.getName() << ": weak alias of '" << *ResolvedSym
<< "'\n");
if (WS.isFunction()) { if (WS.isFunction()) {
assert(WasmIndices.count(ResolvedSym) > 0); assert(WasmIndices.count(ResolvedSym) > 0);
uint32_t WasmIndex = WasmIndices.find(ResolvedSym)->second; uint32_t WasmIndex = WasmIndices.find(ResolvedSym)->second;
WasmIndices[&WS] = WasmIndex; WasmIndices[&WS] = WasmIndex;
DEBUG(dbgs() << " -> index:" << WasmIndex << "\n"); LLVM_DEBUG(dbgs() << " -> index:" << WasmIndex << "\n");
} else if (WS.isData()) { } else if (WS.isData()) {
assert(DataLocations.count(ResolvedSym) > 0); assert(DataLocations.count(ResolvedSym) > 0);
const wasm::WasmDataReference &Ref = const wasm::WasmDataReference &Ref =
DataLocations.find(ResolvedSym)->second; DataLocations.find(ResolvedSym)->second;
DataLocations[&WS] = Ref; DataLocations[&WS] = Ref;
DEBUG(dbgs() << " -> index:" << Ref.Segment << "\n"); LLVM_DEBUG(dbgs() << " -> index:" << Ref.Segment << "\n");
} else { } else {
report_fatal_error("don't yet support global aliases"); report_fatal_error("don't yet support global aliases");
} }
} }
// Finally, populate the symbol table itself, in its "natural" order. // Finally, populate the symbol table itself, in its "natural" order.
for (const MCSymbol &S : Asm.symbols()) { for (const MCSymbol &S : Asm.symbols()) {
const auto &WS = static_cast<const MCSymbolWasm &>(S); const auto &WS = static_cast<const MCSymbolWasm &>(S);
Show All 24 Lines
if (Rel.Type != wasm::R_WEBASSEMBLY_TABLE_INDEX_I32 && if (Rel.Type != wasm::R_WEBASSEMBLY_TABLE_INDEX_I32 &&
Rel.Type != wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB) Rel.Type != wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB)
return; return;
assert(Rel.Symbol->isFunction()); assert(Rel.Symbol->isFunction());
const MCSymbolWasm &WS = *ResolveSymbol(*Rel.Symbol); const MCSymbolWasm &WS = *ResolveSymbol(*Rel.Symbol);
uint32_t FunctionIndex = WasmIndices.find(&WS)->second; uint32_t FunctionIndex = WasmIndices.find(&WS)->second;
uint32_t TableIndex = TableElems.size() + kInitialTableOffset; uint32_t TableIndex = TableElems.size() + kInitialTableOffset;
if (TableIndices.try_emplace(&WS, TableIndex).second) { if (TableIndices.try_emplace(&WS, TableIndex).second) {
DEBUG(dbgs() << " -> adding " << WS.getName() LLVM_DEBUG(dbgs() << " -> adding " << WS.getName()
<< " to table: " << TableIndex << "\n"); << " to table: " << TableIndex << "\n");
TableElems.push_back(FunctionIndex); TableElems.push_back(FunctionIndex);
registerFunctionType(WS); registerFunctionType(WS);
} }
}; };
for (const WasmRelocationEntry &RelEntry : CodeRelocations) for (const WasmRelocationEntry &RelEntry : CodeRelocations)
HandleReloc(RelEntry); HandleReloc(RelEntry);
for (const WasmRelocationEntry &RelEntry : DataRelocations) for (const WasmRelocationEntry &RelEntry : DataRelocations)
Show All 12 Lines

lib/Object/WasmObjectFile.cpp

lib/ProfileData/Coverage/CoverageMapping.cpp

lib/ProfileData/Coverage/CoverageMappingReader.cpp

lib/Support/APInt.cpp

lib/Support/CachePruning.cpp

lib/Support/CommandLine.cpp

lib/Support/DAGDeltaAlgorithm.cpp

lib/Support/Debug.cpp

lib/Support/RandomNumberGenerator.cpp

lib/Target/AArch64/AArch64A53Fix835769.cpp

lib/Target/AArch64/AArch64A57FPLoadBalancing.cpp

lib/Target/AArch64/AArch64AdvSIMDScalarPass.cpp

lib/Target/AArch64/AArch64CollectLOH.cpp

lib/Target/AArch64/AArch64CondBrTuning.cpp

lib/Target/AArch64/AArch64ConditionOptimizer.cpp

lib/Target/AArch64/AArch64ConditionalCompares.cpp

lib/Target/AArch64/AArch64DeadRegisterDefinitionsPass.cpp

lib/Target/AArch64/AArch64FalkorHWPFFix.cpp

lib/Target/AArch64/AArch64FrameLowering.cpp

lib/Target/AArch64/AArch64ISelDAGToDAG.cpp

lib/Target/AArch64/AArch64ISelLowering.cpp

lib/Target/AArch64/AArch64InstructionSelector.cpp

lib/Target/AArch64/AArch64LoadStoreOptimizer.cpp

lib/Target/AArch64/AArch64PBQPRegAlloc.cpp

lib/Target/AArch64/AArch64PromoteConstant.cpp

lib/Target/AArch64/AArch64RedundantCopyElimination.cpp

lib/Target/AArch64/AArch64StorePairSuppress.cpp

lib/Target/AArch64/AArch64TargetTransformInfo.cpp

lib/Target/AMDGPU/AMDGPUInline.cpp

lib/Target/AMDGPU/AMDGPULibCalls.cpp

lib/Target/AMDGPU/AMDGPUMachineCFGStructurizer.cpp

lib/Target/AMDGPU/AMDGPUOpenCLEnqueuedBlockLowering.cpp

lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp

lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp

lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

lib/Target/AMDGPU/AMDILCFGStructurizer.cpp

lib/Target/AMDGPU/GCNILPSched.cpp

lib/Target/AMDGPU/GCNIterativeScheduler.cpp

lib/Target/AMDGPU/GCNMinRegStrategy.cpp

lib/Target/AMDGPU/GCNSchedStrategy.cpp

lib/Target/AMDGPU/R600ClauseMergePass.cpp

lib/Target/AMDGPU/R600ControlFlowFinalizer.cpp

lib/Target/AMDGPU/R600MachineScheduler.cpp

lib/Target/AMDGPU/R600OptimizeVectorRegisters.cpp

lib/Target/AMDGPU/R600Packetizer.cpp

lib/Target/AMDGPU/SIAnnotateControlFlow.cpp

lib/Target/AMDGPU/SIFixSGPRCopies.cpp

lib/Target/AMDGPU/SIFixVGPRCopies.cpp

lib/Target/AMDGPU/SIFoldOperands.cpp

lib/Target/AMDGPU/SIInsertWaitcnts.cpp

lib/Target/AMDGPU/SIInsertWaits.cpp

lib/Target/AMDGPU/SILoadStoreOptimizer.cpp

lib/Target/AMDGPU/SIMachineScheduler.cpp

lib/Target/AMDGPU/SIOptimizeExecMasking.cpp

lib/Target/AMDGPU/SIOptimizeExecMaskingPreRA.cpp

lib/Target/AMDGPU/SIPeepholeSDWA.cpp

lib/Target/AMDGPU/SIShrinkInstructions.cpp

lib/Target/AMDGPU/SIWholeQuadMode.cpp

lib/Target/ARC/ARCBranchFinalize.cpp

lib/Target/ARC/ARCFrameLowering.cpp

lib/Target/ARC/ARCISelLowering.cpp

lib/Target/ARC/ARCInstrInfo.cpp

lib/Target/ARC/ARCRegisterInfo.cpp

lib/Target/ARC/Disassembler/ARCDisassembler.cpp

lib/Target/ARM/A15SDOptimizer.cpp

lib/Target/ARM/ARMBaseInstrInfo.cpp

lib/Target/ARM/ARMBaseRegisterInfo.cpp

lib/Target/ARM/ARMConstantIslandPass.cpp

lib/Target/ARM/ARMFrameLowering.cpp

lib/Target/ARM/ARMISelLowering.cpp

lib/Target/ARM/ARMInstructionSelector.cpp

lib/Target/ARM/ARMLoadStoreOptimizer.cpp

lib/Target/ARM/ARMTargetTransformInfo.cpp

lib/Target/ARM/AsmParser/ARMAsmParser.cpp

lib/Target/ARM/MLxExpansionPass.cpp

lib/Target/ARM/Thumb2SizeReduction.cpp

lib/Target/AVR/AVRISelDAGToDAG.cpp

lib/Target/AVR/AsmParser/AVRAsmParser.cpp

lib/Target/BPF/BPFISelDAGToDAG.cpp

lib/Target/BPF/BPFMIPeephole.cpp

lib/Target/Hexagon/AsmParser/HexagonAsmParser.cpp

lib/Target/Hexagon/HexagonBitSimplify.cpp

lib/Target/Hexagon/HexagonBlockRanges.cpp

lib/Target/Hexagon/HexagonBranchRelaxation.cpp

lib/Target/Hexagon/HexagonCommonGEP.cpp

lib/Target/Hexagon/HexagonConstExtenders.cpp

lib/Target/Hexagon/HexagonConstPropagation.cpp

lib/Target/Hexagon/HexagonCopyToCombine.cpp

lib/Target/Hexagon/HexagonEarlyIfConv.cpp

lib/Target/Hexagon/HexagonExpandCondsets.cpp

lib/Target/Hexagon/HexagonFrameLowering.cpp

lib/Target/Hexagon/HexagonGenPredicate.cpp

lib/Target/Hexagon/HexagonHardwareLoops.cpp

lib/Target/Hexagon/HexagonHazardRecognizer.cpp

lib/Target/Hexagon/HexagonISelDAGToDAG.cpp

lib/Target/Hexagon/HexagonISelLowering.cpp

lib/Target/Hexagon/HexagonInstrInfo.cpp

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

lib/Target/Hexagon/HexagonMachineScheduler.cpp

lib/Target/Hexagon/HexagonNewValueJump.cpp

lib/Target/Hexagon/HexagonOptAddrMode.cpp

lib/Target/Hexagon/HexagonSplitDouble.cpp

lib/Target/Hexagon/HexagonStoreWidening.cpp

lib/Target/Hexagon/HexagonTargetObjectFile.cpp

lib/Target/Hexagon/HexagonVLIWPacketizer.cpp

lib/Target/Hexagon/HexagonVectorLoopCarriedReuse.cpp

lib/Target/Hexagon/HexagonVectorPrint.cpp

lib/Target/Hexagon/MCTargetDesc/HexagonAsmBackend.cpp

lib/Target/Hexagon/MCTargetDesc/HexagonMCCodeEmitter.cpp

lib/Target/Hexagon/MCTargetDesc/HexagonMCCompound.cpp

lib/Target/Hexagon/MCTargetDesc/HexagonMCDuplexInfo.cpp

lib/Target/Hexagon/MCTargetDesc/HexagonMCShuffler.cpp

lib/Target/Hexagon/MCTargetDesc/HexagonShuffler.cpp

lib/Target/Lanai/LanaiISelDAGToDAG.cpp

lib/Target/Lanai/LanaiISelLowering.cpp

lib/Target/MSP430/MSP430BranchSelector.cpp

lib/Target/MSP430/MSP430ISelDAGToDAG.cpp

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

lib/Target/Mips/Disassembler/MipsDisassembler.cpp

lib/Target/Mips/MCTargetDesc/MipsELFObjectWriter.cpp

lib/Target/Mips/MicroMipsSizeReduction.cpp

lib/Target/Mips/Mips16HardFloat.cpp

lib/Target/Mips/Mips16RegisterInfo.cpp

lib/Target/Mips/MipsConstantIslandPass.cpp

lib/Target/Mips/MipsFastISel.cpp

lib/Target/Mips/MipsISelDAGToDAG.cpp

lib/Target/Mips/MipsModuleISelDAGToDAG.cpp

lib/Target/Mips/MipsOs16.cpp

lib/Target/Mips/MipsRegisterInfo.cpp

lib/Target/Mips/MipsSEISelLowering.cpp

lib/Target/Mips/MipsSERegisterInfo.cpp

lib/Target/Mips/MipsSubtarget.cpp

lib/Target/Mips/MipsTargetMachine.cpp

lib/Target/NVPTX/NVPTXPrologEpilogPass.cpp

lib/Target/NVPTX/NVVMReflect.cpp

lib/Target/Nios2/Nios2ISelDAGToDAG.cpp

lib/Target/PowerPC/PPCAsmPrinter.cpp

lib/Target/PowerPC/PPCBranchCoalescing.cpp

lib/Target/PowerPC/PPCCTRLoops.cpp

lib/Target/PowerPC/PPCExpandISEL.cpp

lib/Target/PowerPC/PPCHazardRecognizers.cpp

lib/Target/PowerPC/PPCISelDAGToDAG.cpp

lib/Target/PowerPC/PPCISelLowering.cpp

lib/Target/PowerPC/PPCInstrInfo.cpp

lib/Target/PowerPC/PPCLoopPreIncPrep.cpp

lib/Target/PowerPC/PPCMIPeephole.cpp

lib/Target/PowerPC/PPCPreEmitPeephole.cpp

lib/Target/PowerPC/PPCReduceCRLogicals.cpp

lib/Target/PowerPC/PPCTLSDynamicCall.cpp

lib/Target/PowerPC/PPCVSXFMAMutate.cpp

lib/Target/PowerPC/PPCVSXSwapRemoval.cpp

lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp

lib/Target/RISCV/RISCVISelDAGToDAG.cpp

lib/Target/RISCV/RISCVISelLowering.cpp

lib/Target/SystemZ/SystemZHazardRecognizer.cpp

lib/Target/SystemZ/SystemZISelDAGToDAG.cpp

lib/Target/SystemZ/SystemZMachineScheduler.cpp

lib/Target/WebAssembly/WebAssemblyArgumentMove.cpp

lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

lib/Target/WebAssembly/WebAssemblyCFGSort.cpp

lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp

lib/Target/WebAssembly/WebAssemblyCallIndirectFixup.cpp

lib/Target/WebAssembly/WebAssemblyExplicitLocals.cpp

lib/Target/WebAssembly/WebAssemblyFixIrreducibleControlFlow.cpp

lib/Target/WebAssembly/WebAssemblyISelDAGToDAG.cpp

lib/Target/WebAssembly/WebAssemblyLowerBrUnless.cpp

lib/Target/WebAssembly/WebAssemblyOptimizeLiveIntervals.cpp

lib/Target/WebAssembly/WebAssemblyPeephole.cpp

lib/Target/WebAssembly/WebAssemblyPrepareForLiveIntervals.cpp

lib/Target/WebAssembly/WebAssemblyRegColoring.cpp

lib/Target/WebAssembly/WebAssemblyRegNumbering.cpp

lib/Target/WebAssembly/WebAssemblyRegStackify.cpp

lib/Target/WebAssembly/WebAssemblyReplacePhysRegs.cpp

lib/Target/WebAssembly/WebAssemblySetP2AlignOperands.cpp

lib/Target/WebAssembly/WebAssemblyStoreResults.cpp

lib/Target/X86/Disassembler/X86Disassembler.cpp

lib/Target/X86/X86CmovConversion.cpp

lib/Target/X86/X86DomainReassignment.cpp

lib/Target/X86/X86FixupBWInsts.cpp

lib/Target/X86/X86FixupLEAs.cpp

lib/Target/X86/X86FloatingPoint.cpp

lib/Target/X86/X86ISelDAGToDAG.cpp

lib/Target/X86/X86InstrInfo.cpp

lib/Target/X86/X86InstructionSelector.cpp

lib/Target/X86/X86OptimizeLEAs.cpp

lib/Target/X86/X86RetpolineThunks.cpp

lib/Target/X86/X86Subtarget.cpp

lib/Target/X86/X86VZeroUpper.cpp

lib/Target/X86/X86WinEHState.cpp

lib/Target/XCore/XCoreRegisterInfo.cpp

lib/Transforms/AggressiveInstCombine/TruncInstCombine.cpp

lib/Transforms/Coroutines/CoroFrame.cpp

lib/Transforms/Coroutines/CoroSplit.cpp

lib/Transforms/IPO/ArgumentPromotion.cpp

lib/Transforms/IPO/BlockExtractor.cpp

lib/Transforms/IPO/DeadArgumentElimination.cpp

lib/Transforms/IPO/ForceFunctionAttrs.cpp

lib/Transforms/IPO/FunctionAttrs.cpp

lib/Transforms/IPO/FunctionImport.cpp

lib/Transforms/IPO/GlobalOpt.cpp

lib/Transforms/IPO/Inliner.cpp

lib/Transforms/IPO/Internalize.cpp

lib/Transforms/IPO/LowerTypeTests.cpp

lib/Transforms/IPO/MergeFunctions.cpp

lib/Transforms/IPO/SampleProfile.cpp

lib/Transforms/InstCombine/InstCombineCalls.cpp

lib/Transforms/InstCombine/InstCombineCasts.cpp

lib/Transforms/InstCombine/InstCombineInternal.h

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

lib/Transforms/InstCombine/InstCombinePHI.cpp

lib/Transforms/InstCombine/InstCombineShifts.cpp

lib/Transforms/InstCombine/InstructionCombining.cpp

lib/Transforms/Instrumentation/AddressSanitizer.cpp

lib/Transforms/Instrumentation/BoundsChecking.cpp

lib/Transforms/Instrumentation/CFGMST.h

lib/Transforms/Instrumentation/GCOVProfiling.cpp

lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

lib/Transforms/Instrumentation/IndirectCallPromotion.cpp

lib/Transforms/Instrumentation/InstrProfiling.cpp

lib/Transforms/Instrumentation/MemorySanitizer.cpp

lib/Transforms/Instrumentation/PGOInstrumentation.cpp

lib/Transforms/Instrumentation/PGOMemOPSizeOpt.cpp

lib/Transforms/Instrumentation/ThreadSanitizer.cpp

lib/Transforms/ObjCARC/ObjCARCAPElim.cpp

lib/Transforms/ObjCARC/ObjCARCContract.cpp

lib/Transforms/ObjCARC/ObjCARCExpand.cpp

lib/Transforms/ObjCARC/ObjCARCOpts.cpp

lib/Transforms/ObjCARC/PtrState.cpp

lib/Transforms/Scalar/ADCE.cpp

lib/Transforms/Scalar/AlignmentFromAssumptions.cpp

lib/Transforms/Scalar/BDCE.cpp

lib/Transforms/Scalar/CallSiteSplitting.cpp

lib/Transforms/Scalar/ConstantHoisting.cpp

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

lib/Transforms/Scalar/DeadStoreElimination.cpp

lib/Transforms/Scalar/EarlyCSE.cpp

lib/Transforms/Scalar/Float2Int.cpp

lib/Transforms/Scalar/GVN.cpp

lib/Transforms/Scalar/GVNHoist.cpp

lib/Transforms/Scalar/GVNSink.cpp

lib/Transforms/Scalar/GuardWidening.cpp

lib/Transforms/Scalar/IndVarSimplify.cpp

lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

lib/Transforms/Scalar/InferAddressSpaces.cpp

lib/Transforms/Scalar/JumpThreading.cpp

lib/Transforms/Scalar/LICM.cpp

lib/Transforms/Scalar/LoopDataPrefetch.cpp

lib/Transforms/Scalar/LoopDeletion.cpp

lib/Transforms/Scalar/LoopDistribute.cpp

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

lib/Transforms/Scalar/LoopInterchange.cpp

lib/Transforms/Scalar/LoopLoadElimination.cpp

lib/Transforms/Scalar/LoopPredication.cpp

lib/Transforms/Scalar/LoopRerollPass.cpp

lib/Transforms/Scalar/LoopRotation.cpp

lib/Transforms/Scalar/LoopSink.cpp

lib/Transforms/Scalar/LoopStrengthReduce.cpp

lib/Transforms/Scalar/LoopUnrollPass.cpp

lib/Transforms/Scalar/LoopUnswitch.cpp

lib/Transforms/Scalar/LoopVersioningLICM.cpp

lib/Transforms/Scalar/MemCpyOptimizer.cpp

lib/Transforms/Scalar/MergeICmps.cpp

lib/Transforms/Scalar/MergedLoadStoreMotion.cpp

lib/Transforms/Scalar/NewGVN.cpp

lib/Transforms/Scalar/PlaceSafepoints.cpp

lib/Transforms/Scalar/Reassociate.cpp

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

lib/Transforms/Scalar/SCCP.cpp

lib/Transforms/Scalar/SROA.cpp

lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

lib/Transforms/Scalar/Sink.cpp

lib/Transforms/Scalar/SpeculateAroundPHIs.cpp

lib/Transforms/Scalar/SpeculativeExecution.cpp

lib/Transforms/Scalar/StructurizeCFG.cpp

lib/Transforms/Scalar/TailRecursionElimination.cpp

lib/Transforms/Utils/AddDiscriminators.cpp

lib/Transforms/Utils/CodeExtractor.cpp

lib/Transforms/Utils/CtorUtils.cpp

lib/Transforms/Utils/Evaluator.cpp

lib/Transforms/Utils/FlattenCFG.cpp

lib/Transforms/Utils/FunctionComparator.cpp

lib/Transforms/Utils/LibCallsShrinkWrap.cpp

lib/Transforms/Utils/Local.cpp

lib/Transforms/Utils/LoopSimplify.cpp

lib/Transforms/Utils/LoopUnroll.cpp

lib/Transforms/Utils/LoopUnrollPeel.cpp

lib/Transforms/Utils/LoopUnrollRuntime.cpp

lib/Transforms/Utils/LoopUtils.cpp

lib/Transforms/Utils/LowerSwitch.cpp

lib/Transforms/Utils/PredicateInfo.cpp

lib/Transforms/Utils/SSAUpdater.cpp

lib/Transforms/Utils/SimplifyCFG.cpp

lib/Transforms/Utils/SimplifyIndVar.cpp

lib/Transforms/Utils/SplitModule.cpp

lib/Transforms/Utils/VNCoercion.cpp

lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

lib/Transforms/Vectorize/LoopVectorize.cpp

lib/Transforms/Vectorize/SLPVectorizer.cpp

lib/Transforms/Vectorize/VPlan.cpp

tools/bugpoint/ExtractFunction.cpp

tools/bugpoint/OptimizerDriver.cpp

tools/bugpoint/ToolRunner.cpp

tools/lli/lli.cpp

tools/llvm-dwarfdump/Statistics.cpp

tools/verify-uselistorder/verify-uselistorder.cpp

unittests/IR/CFGBuilder.cpp

unittests/IR/DominatorTreeBatchUpdatesTest.cpp

utils/TableGen/AsmMatcherEmitter.cpp

utils/TableGen/AsmWriterEmitter.cpp

utils/TableGen/CodeGenDAGPatterns.cpp

utils/TableGen/CodeGenRegisters.cpp

utils/TableGen/CodeGenSchedule.cpp

utils/TableGen/DAGISelEmitter.cpp

utils/TableGen/DAGISelMatcherOpt.cpp

utils/TableGen/DFAPacketizerEmitter.cpp

utils/TableGen/FixedLenDecoderEmitter.cpp

utils/TableGen/GlobalISelEmitter.cpp

utils/TableGen/PseudoLoweringEmitter.cpp

utils/TableGen/RegisterBankEmitter.cpp

utils/TableGen/SubtargetEmitter.cpp