[dump] Make LLVM_ENABLE_DUMP independent, and move to llvm-config.h

[hintonda]

Summary

Make LLVM_ENABLE_DUMP independent LLVM_ENABLE_ASSERTIONS, move it to llvm-config.h, and update description.

[hintonda]

While #ifdef LLVM_ENABLE_DUMP is arguably better than #ifndef NDEBUG, it's still problematic if we extend this to declarations in headers. Some headers that declare void dump() const, don't include any headers, so they won't #ifdef away the declaration which would have helped catch the problem at compile-time.

To fix this, we could test for a value instead of just definition, i.e., #if LLVM_ENABLE_DUMP, or even #if LLVM_ENABLE_DUMP > [some value].

That way, we are guaranteed to get a compile-time error.

[MatzeB]

I like this change.

In D38406#884686, @hintonda wrote:

While #ifdef LLVM_ENABLE_DUMP is arguably better than #ifndef NDEBUG, it's still problematic if we extend this to declarations in headers. Some headers that declare void dump() const, don't include any headers, so they won't #ifdef away the declaration which would have helped catch the problem at compile-time.

To put it differently: Your concern is that someone uses #ifdef LLVM_ENABLE_DUMP but forgets the #include "llvm/Config/llvm-config.h"?

To fix this, we could test for a value instead of just definition, i.e., #if LLVM_ENABLE_DUMP, or even #if LLVM_ENABLE_DUMP > [some value].

I'm not convinced that helps all that much (not that it is a problem either though).
You would expect to see compile problems when implementing the dump() function if llvm-config.h wasn't present in the header. It's also customary to include "foo.h" as first thing in "foo.cpp" so we have at least 1 file where we only have a no other headers included before "foo.h".
So I'd lean towards staying with #ifdef LLVM_ENABLE_DUMP as that is a more common idiom which avoids the other failure case where someone does #ifdef XXX working anyway even though XXX was defined to 0.

(No strong opinion from my side though so if others disagree I can be convinced to use this style).

[hintonda]

In D38406#884703, @MatzeB wrote:

I like this change.

In D38406#884686, @hintonda wrote:

While #ifdef LLVM_ENABLE_DUMP is arguably better than #ifndef NDEBUG, it's still problematic if we extend this to declarations in headers. Some headers that declare void dump() const, don't include any headers, so they won't #ifdef away the declaration which would have helped catch the problem at compile-time.

To put it differently: Your concern is that someone uses #ifdef LLVM_ENABLE_DUMP but forgets the #include "llvm/Config/llvm-config.h"?

Yes, but as you mentioned below, it would be pretty rare. The only reason I brought it up would be to reduce churn if we did decide to go that route.

To fix this, we could test for a value instead of just definition, i.e., #if LLVM_ENABLE_DUMP, or even #if LLVM_ENABLE_DUMP > [some value].

I'm not convinced that helps all that much (not that it is a problem either though).
You would expect to see compile problems when implementing the dump() function if llvm-config.h wasn't present in the header. It's also customary to include "foo.h" as first thing in "foo.cpp" so we have at least 1 file where we only have a no other headers included before "foo.h".
So I'd lean towards staying with #ifdef LLVM_ENABLE_DUMP as that is a more common idiom which avoids the other failure case where someone does #ifdef XXX working anyway even though XXX was defined to 0.

(No strong opinion from my side though so if others disagree I can be convinced to use this style).

[MatzeB]

Just noticed I didn't get around accepting this even though it looks good. LGTM

[hintonda]

Re-opening:

This was reverted in rL315854 due to bot failures using multi-configuration generators, e.g., XCode and MSVC.

There were 2 issues:

1. LLVM_ENABLE_DEBUG was missing on some dump declartions,
2. LLVM_ENABLE_DEBUG was set based on CMAKE_BUILD_TYPE which isn't set when using multi-configuration generators.

We can fix 1 as needed, and 2 by adding LLVM_ENABLE_DUMP to CMAKE_CXX_FLAGS_(RELEASE|MINSIZEREL) as needed.

[MatzeB]

In D38406#944576, @hintonda wrote:

Re-opening:

This was reverted in rL315854 due to bot failures using multi-configuration generators, e.g., XCode and MSVC.

There were 2 issues:

1. LLVM_ENABLE_DEBUG was missing on some dump declartions,
2. LLVM_ENABLE_DEBUG was set based on CMAKE_BUILD_TYPE which isn't set when using multi-configuration generators.

We can fix 1 as needed, and 2 by adding LLVM_ENABLE_DUMP to CMAKE_CXX_FLAGS_(RELEASE|MINSIZEREL) as needed.

Just some brainstorming for the generator problems (didn't really check if cmake is flexible enough to pull this off): Would it be possible to do cmake hackery to create a directory for every CMAKE_BUILD_TYPE and then generate the llvm-config.h apropriate for each BUILT_TYPE into each directory and add an -I flag to the flags of each build type.

[hintonda]

Pass LLVM_ENABLE_DUMP to appropriate CMAKE_CXX_FLAGS_<config>
variables instead of hard coding in config.h or llvm-config.h.

[hintonda]

In D38406#944588, @MatzeB wrote:

In D38406#944576, @hintonda wrote:

Re-opening:

This was reverted in rL315854 due to bot failures using multi-configuration generators, e.g., XCode and MSVC.

There were 2 issues:

1. LLVM_ENABLE_DEBUG was missing on some dump declartions,
2. LLVM_ENABLE_DEBUG was set based on CMAKE_BUILD_TYPE which isn't set when using multi-configuration generators.

We can fix 1 as needed, and 2 by adding LLVM_ENABLE_DUMP to CMAKE_CXX_FLAGS_(RELEASE|MINSIZEREL) as needed.

Just some brainstorming for the generator problems (didn't really check if cmake is flexible enough to pull this off): Would it be possible to do cmake hackery to create a directory for every CMAKE_BUILD_TYPE and then generate the llvm-config.h apropriate for each BUILT_TYPE into each directory and add an -I flag to the flags of each build type.

Config directories are already created, e.g.: Release, Debug, etc., with bin and lib subdirs in each. We could easily add an include subdir to each, but then it gets complicated with adding -I as you mentioned.

But since the CMAKE_CXX_FLAGS_<config> variable already handles this, and also works for the case where headers don't include any other headers, I think it's a more general solution -- this was brought up by Justin Bogner earlier this evening, e.g.: MC/MCSchedule.h.

[MatzeB]

CMakeLists.txt

390–393 ↗

(On Diff #125462)

Dynamically switching defaults in cmake is usually a bad idea. As that will only have an effect the first time cmake runs, AFAIK in subsequent cmake runs changing the default has no effect anymore as there is already a value in the cmake cache which will be unexpected by the user.

(i.e. cmake -DCMAKE_BUILD_TYPE=DEBUG ; cmake -DCMAKE_BUILD_TYPE=RELEASE will give you a different value for LLVM_ENABLE_DUMP than cmake -DCMAKE_BUILD_TYPE=RELEASE assuming an empty build dir)

[MatzeB]

CMakeLists.txt

390–393 ↗

(On Diff #125462)

(Yes we already screwed this up with ENABLE_ASSERTIONS IMO, but no reason to screw it up with ENABLE_DUMP too IMO)

[hintonda]

• Allow rerunning cmake with different values for build type or LLVM_ENABLE_ASSERTIONS.

[hintonda]

CMakeLists.txt

390–393 ↗

(On Diff #125462)

This now works for your example. If we want to be able to pass LLVM_ENABLE_DUMP independently, we can do that with the additional LLVM_FORCE_ENABLE_DUMP, but it should still work that same as ASSERTIONS.

[hintonda]

Change LLVM_ENABLE_ASSERTIONS and LLVM_ENABLE_DUMP to non-cached
variables so we can determine if they were passed on the command line
and set defaults if not defined.

Only add/clear -DLLVM_ENABLE_DUMP in config specific
CMAKE_CXX_FLAGS_<config> variable corresponding to the current
CMAKE_BUILD_TYPE.

This configuration allows users to re-run cmake with different
CMAKE_BUILD_TYPE, LLVM_ENABLE_ASSERTIONS, or LLVM_ENABLE_DUMP and
update the appropriate CMAKE_CXX_FLAGS_<config> variable.

[hintonda]

When variables are passed on the command line, they are automatically cached
so that subsequent cmake runs will give identical results, i.e., as if the variables
were passed again. However, this makes it somewhat difficult to toggle options
since they look exactly the same and you don't know if the variable came from
the command line or the cache.

The current version of this patch doesn't handle this cleanly, but below is a simple
example of how to toggle variables (FOO in this case) on a per config basis.
Once set, the variable stays set until explicitly cleared.

I believe this technique could be used for both LLVM_ENABLE_DUMP
and LLVM_ENABLE_ASSERTIONS. Please let me know what you think.

local:/Users/dhinton/cmt/test $ cat ../CMakeLists.txt
cmake_minimum_required(VERSION 3.5)
string(TOUPPER ${CMAKE_BUILD_TYPE} uppercase_CMAKE_BUILD_TYPE)

# Do not cache FOO -- only allow it to be passed from the command line
# -- but set and cache the appropriate build type version instead.
if (DEFINED FOO)
  foreach(lang C CXX)
                if (FOO AND NOT FOO_${uppercase_CMAKE_BUILD_TYPE})
      set(CMAKE_${lang}_FLAGS_${uppercase_CMAKE_BUILD_TYPE}
          "${CMAKE_${lang}_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} -DFOO")
                elseif (NOT ${FOO})
      string(REGEX REPLACE " *-DFOO *" " "
             CMAKE_${lang}_FLAGS_${uppercase_CMAKE_BUILD_TYPE}
             "${CMAKE_${lang}_FLAGS_${uppercase_CMAKE_BUILD_TYPE}}")
    endif()
    string(STRIP "${CMAKE_${lang}_FLAGS_${uppercase_CMAKE_BUILD_TYPE}}"
           CMAKE_${lang}_FLAGS_${uppercase_CMAKE_BUILD_TYPE})
    set(CMAKE_${lang}_FLAGS_${uppercase_CMAKE_BUILD_TYPE}
        "${CMAKE_${lang}_FLAGS_${uppercase_CMAKE_BUILD_TYPE}}" CACHE STRING "" FORCE)
  endforeach()

  set(FOO_${uppercase_CMAKE_BUILD_TYPE} ${FOO} CACHE BOOL "" FORCE)
        unset(FOO CACHE)
endif()

local:/Users/dhinton/cmt/test $ rm -rf *
local:/Users/dhinton/cmt/test $ cmake ../ -DCMAKE_BUILD_TYPE=Debug > /dev/null 2>&1 && grep -E "_CXX_FLAGS_(DEBUG|RELEASE):" CMakeCache.txt
CMAKE_CXX_FLAGS_DEBUG:STRING=-g
CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG

local:/Users/dhinton/cmt/test $ cmake ../ -DCMAKE_BUILD_TYPE=Release > /dev/null 2>&1 && grep -E "_CXX_FLAGS_(DEBUG|RELEASE):" CMakeCache.txt
CMAKE_CXX_FLAGS_DEBUG:STRING=-g
CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG

local:/Users/dhinton/cmt/test $ cmake ../ -DCMAKE_BUILD_TYPE=Release -DFOO=On > /dev/null 2>&1 && grep -E "_CXX_FLAGS_(DEBUG|RELEASE):" CMakeCache.txt
CMAKE_CXX_FLAGS_DEBUG:STRING=-g
CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG -DFOO

local:/Users/dhinton/cmt/test $ cmake ../ -DCMAKE_BUILD_TYPE=Debug > /dev/null 2>&1 && grep -E "_CXX_FLAGS_(DEBUG|RELEASE):" CMakeCache.txt
CMAKE_CXX_FLAGS_DEBUG:STRING=-g
CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG -DFOO

local:/Users/dhinton/cmt/test $ cmake ../ -DCMAKE_BUILD_TYPE=Debug -DFOO=Off > /dev/null 2>&1 && grep -E "_CXX_FLAGS_(DEBUG|RELEASE):" CMakeCache.txt
CMAKE_CXX_FLAGS_DEBUG:STRING=-g
CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG -DFOO

local:/Users/dhinton/cmt/test $ cmake ../ -DCMAKE_BUILD_TYPE=Release > /dev/null 2>&1 && grep -E "_CXX_FLAGS_(DEBUG|RELEASE):" CMakeCache.txt
CMAKE_CXX_FLAGS_DEBUG:STRING=-g
CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG -DFOO

local:/Users/dhinton/cmt/test $ cmake ../ -DCMAKE_BUILD_TYPE=Release -DFOO=Off > /dev/null 2>&1 && grep -E "_CXX_FLAGS_(DEBUG|RELEASE):" CMakeCache.txt
CMAKE_CXX_FLAGS_DEBUG:STRING=-g
CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG

[bogner]

I don't really think we want to be messing with the CMAKE_CXX_FLAGS_{BUILD_TYPE} variables for this. All of this regex-replace stuff is very complicated and seems fragile.

A couple of things need to happen:

1. LLVM_ENABLE_DUMP definitely needs to be defined in llvm-config.h, or we won't be able to safely use it in headers. Headers that use it should include llvm-config.h

2. While we probably don't want to set a cache variable's value based on the value of assertions, if the user explicitly specifies it we probably do want to trust them. I think having LLVM_ENABLE_DUMP be computed / non-cached and basing it off of LLVM_ENABLE_ASSERTIONS and LLVM_FORCE_ENABLE_DUMP is probably the clearest thing to do here, though that does hit the problem that people already having LLVM_ENABLE_DUMP in their caches. Maybe it would work to set the non-cached version based off of asserts iff the cached version is unset?

[hintonda]

In D38406#945809, @bogner wrote:

I don't really think we want to be messing with the CMAKE_CXX_FLAGS_{BUILD_TYPE} variables for this. All of this regex-replace stuff is very complicated and seems fragile.

A couple of things need to happen:

1. LLVM_ENABLE_DUMP definitely needs to be defined in llvm-config.h, or we won't be able to safely use it in headers. Headers that use it should include llvm-config.h

2. While we probably don't want to set a cache variable's value based on the value of assertions, if the user explicitly specifies it we probably do want to trust them. I think having LLVM_ENABLE_DUMP be computed / non-cached and basing it off of LLVM_ENABLE_ASSERTIONS and LLVM_FORCE_ENABLE_DUMP is probably the clearest thing to do here, though that does hit the problem that people already having LLVM_ENABLE_DUMP in their caches. Maybe it would work to set the non-cached version based off of asserts iff the cached version is unset?

If this would work for XCode and MSVC generators -- the MSVC generator breakage Aaron reported was the main reason this was originally rolled back -- then I'd be all for it.

My solution would support buildbots, developer builds, and installed versions via llvm-config. What you've proposed would only support ninja/make and installed versions. Btw, I only use ninja, so I'd love to do what you propose -- why would anyone use anything else, right? ;-)

However, I don't see a way to solve the multi-config issue without either using config specific variables, e.g., CMAKE_CXX_FLAGS_RELEASE (the solution I"m proposing), or config specific lvm-config.h files, e.g., builddir/Release/include/llvm-config.h and passing -I in dev builds -- installed versions would just install the correct llvm-config.h (which is what Mathias was alluding to).

Of course, I might be missing something, so if you've got a solution that will solve all of these problems, I'm all in. I just don't see how hard coding it in a single llvm-config.h could work.

[bogner]

In D38406#945845, @hintonda wrote:

My solution would support buildbots, developer builds, and installed versions via llvm-config.

I don't understand how this version supports installed versions, the define doesn't appear in llvm-config at all here. Can you explain?

[MatzeB]

In D38406#945869, @bogner wrote:

In D38406#945845, @hintonda wrote:

My solution would support buildbots, developer builds, and installed versions via llvm-config.

I don't understand how this version supports installed versions, the define doesn't appear in llvm-config at all here. Can you explain?

While I could see an llvm-config solution working, I'd really rather see us try the llvm-config.h solution first. In my experience people who do not come from a unix/linux background usually setup their own projects in various IDEs and do not profit from an llvm-config tool feeding them the right flags, they would have to discover the right flags themselfes if they aren't in llvm-config.h.

[bogner]

I'm also confused about how this works before this change, if multi-config generators only create one set of headers. Currently, we're already defining LLVM_ENABLE_DUMP in config.h, so how does MSVC handle the fact that this already has different values for different configs?

[hintonda]

In D38406#945869, @bogner wrote:

In D38406#945845, @hintonda wrote:

My solution would support buildbots, developer builds, and installed versions via llvm-config.

I don't understand how this version supports installed versions, the define doesn't appear in llvm-config at all here. Can you explain?

I was planning on using llvm-config, e.g.:

local:/Users/dhinton/projects/llvm_project/build/Debug $ bin/llvm-config --cxxflags
-I/Users/dhinton/projects/llvm_project/llvm/include -I/Users/dhinton/projects/llvm_project/build/Debug/include  -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -std=c++11 -Wall -W -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wcovered-switch-default -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wstring-conversion -fcolor-diagnostics -O3  -DLLVM_ENABLE_DUMP  -fno-exceptions -fno-rtti -D_DEBUG -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS

[hintonda]

In D38406#945892, @hintonda wrote:

In D38406#945869, @bogner wrote:

In D38406#945845, @hintonda wrote:

My solution would support buildbots, developer builds, and installed versions via llvm-config.

I don't understand how this version supports installed versions, the define doesn't appear in llvm-config at all here. Can you explain?

I was planning on using llvm-config, e.g.:

local:/Users/dhinton/projects/llvm_project/build/Debug $ bin/llvm-config --cxxflags
-I/Users/dhinton/projects/llvm_project/llvm/include -I/Users/dhinton/projects/llvm_project/build/Debug/include  -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -std=c++11 -Wall -W -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wcovered-switch-default -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wstring-conversion -fcolor-diagnostics -O3  -DLLVM_ENABLE_DUMP  -fno-exceptions -fno-rtti -D_DEBUG -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS

Btw, this was configured with cmake -GNinja ../../llvm -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=On against the current patch.

[hintonda]

In D38406#945890, @bogner wrote:

I'm also confused about how this works before this change, if multi-config generators only create one set of headers. Currently, we're already defining LLVM_ENABLE_DUMP in config.h, so how does MSVC handle the fact that this already has different values for different configs?

That's the problem, as far as I can tell, it never worked. It always depended on NDEBUG.

[bogner]

In D38406#945892, @hintonda wrote:

I was planning on using llvm-config, e.g.:

local:/Users/dhinton/projects/llvm_project/build/Debug $ bin/llvm-config --cxxflags
-I/Users/dhinton/projects/llvm_project/llvm/include -I/Users/dhinton/projects/llvm_project/build/Debug/include  -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -std=c++11 -Wall -W -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wcovered-switch-default -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wstring-conversion -fcolor-diagnostics -O3  -DLLVM_ENABLE_DUMP  -fno-exceptions -fno-rtti -D_DEBUG -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS

Ah, that llvm-config. Sorry, I got confused about that and llvm-config.h.

This sort of works, but I don't think it's optimal. Most users of llvm as a library I'm aware of don't use llvm-config --cxxflags (though they often do use other llvm-config flags). This command lists a number of flags that you don't necessarily want when building against llvm (like the specific warning settings).

[hintonda]

In D38406#945888, @MatzeB wrote:

In D38406#945869, @bogner wrote:

In D38406#945845, @hintonda wrote:

My solution would support buildbots, developer builds, and installed versions via llvm-config.

I don't understand how this version supports installed versions, the define doesn't appear in llvm-config at all here. Can you explain?

While I could see an llvm-config solution working, I'd really rather see us try the llvm-config.h solution first. In my experience people who do not come from a unix/linux background usually setup their own projects in various IDEs and do not profit from an llvm-config tool feeding them the right flags, they would have to discover the right flags themselfes if they aren't in llvm-config.h.

I can do this, but I got a lot of push back from multiple people at the dev meeting when I floated this idea, so I didn't pursue it. The complaint seemed to be multiple files and -I directives would be too confusing. Btw, we'll have to munge the command line variables based on the config. I'll give it a try and get back to you.

[MatzeB]

In D38406#945939, @hintonda wrote:

In D38406#945888, @MatzeB wrote:

In D38406#945869, @bogner wrote:

In D38406#945845, @hintonda wrote:

My solution would support buildbots, developer builds, and installed versions via llvm-config.

I don't understand how this version supports installed versions, the define doesn't appear in llvm-config at all here. Can you explain?

While I could see an llvm-config solution working, I'd really rather see us try the llvm-config.h solution first. In my experience people who do not come from a unix/linux background usually setup their own projects in various IDEs and do not profit from an llvm-config tool feeding them the right flags, they would have to discover the right flags themselfes if they aren't in llvm-config.h.

I can do this, but I got a lot of push back from multiple people at the dev meeting when I floated this idea, so I didn't pursue it. The complaint seemed to be multiple files and -I directives would be too confusing. Btw, we'll have to munge the command line variables based on the config. I'll give it a try and get back to you.

While it's complicated/annoying that we have to do this, so far every other solution seems worse to me. So I'd definitely support the multiple llvm-config.h in different directories approach.

[hintonda]

Make LLVM_ENABLE_DUMP independent of LLVM_ENABLE_ASSERTIONS, and move
the LLVM_ENABLE_DUMP define from config.h to llvm-config.h.

This patch was originally motivated by a desire to better control
LLVM_ENABLE_DUMP defaults based on the current build type -- much like
LLVM_ENABLE_ASSERTIONS handles it -- as well as clean up the locations
in the code. Unfortunately, many locations only tested for NDEBUG, so
the cleanup caused a problem.

Also, the complexities of handling multiple build types, especially
for multi-config generators like Xcode and MSVC, made it really
difficult to effectively control LLVM_ENABLE_DUMP at that granularity.
The only way to do this would involve adding a command line option
(via either a -D or -I options), but that defeats the purpose of
moving LLVM_ENABLE_DUMP to a header file in the first place -- it was
originally set via a cmake add_definitions directive.

[MatzeB]

(via either a -D or -I options), but that defeats the purpose of moving LLVM_ENABLE_DUMP to a header file in the first place -- it was originally set via a cmake add_definitions directive.

It doesn't really defeat that purpose: From the point of view of an external llvm user no flags need to be set at all! (Assuming someone prepared a nice package where llvm-config.h just lives next to all the other headers). The complexity of creating multiple llvm-config.h files in different directories and adding different -I to have each config include their specific directory is contained within llvms build system.

[MatzeB]

Though admittedly I like the solution here for its simplicity. However we should change the default to ON. The only downside is obviously external packagers need to be aware of the flag now to take advantage in their releases but I personally can live with that given that this is only about a few kilobytes saved in release libraries I believe.

[hintonda]

• Set LLVM_ENABLE_DUMP default to ON.

[MatzeB]

Let's wait a bit to see if this is fine with people. It would probably be also nice to add the set(LLVM_ENABLE_DUMP OFF CACHE BOOL "") line to the varous caches in clang/cmake/caches that build llvm in release build types.

CMakeLists.txt

388 ↗

(On Diff #125843)

Should also change the description to "Enable dump functions" (without the "in release builds") now.

[hintonda]

In D38406#947437, @MatzeB wrote:

(via either a -D or -I options), but that defeats the purpose of moving LLVM_ENABLE_DUMP to a header file in the first place -- it was originally set via a cmake add_definitions directive.

It doesn't really defeat that purpose: From the point of view of an external llvm user no flags need to be set at all! (Assuming someone prepared a nice package where llvm-config.h just lives next to all the other headers). The complexity of creating multiple llvm-config.h files in different directories and adding different -I to have each config include their specific directory is contained within llvms build system.

What I meant was that by putting it in a header, means it could be used without additional user input.

[hintonda]

In D38406#947470, @MatzeB wrote:

Let's wait a bit to see if this is fine with people. It would probably be also nice to add the set(LLVM_ENABLE_DUMP OFF CACHE BOOL "") line to the varous caches in clang/cmake/caches that build llvm in release build types.

I don't mind changing the default, but the original default was OFF, and only flipped to ON if LLVM_ENABLE_ASSERTIONS was ON. But that had no affect, since enabling assertions removed -DNDEBUG and added -UNDEBUG, so all the dump definitions were already enabled. Setting LLVM_ENABLE_DUMP=ON only makes sense for non-debug builds where LLVM_ENABLE_ASSERTIONS=OFF.

So, I think maintaining the default of OFF is the correct choice, but will set it to whatever you want.

[MatzeB]

In D38406#947491, @hintonda wrote:

In D38406#947470, @MatzeB wrote:

Let's wait a bit to see if this is fine with people. It would probably be also nice to add the set(LLVM_ENABLE_DUMP OFF CACHE BOOL "") line to the varous caches in clang/cmake/caches that build llvm in release build types.

I don't mind changing the default, but the original default was OFF, and only flipped to ON if LLVM_ENABLE_ASSERTIONS was ON. But that had no affect, since enabling assertions removed -DNDEBUG and added -UNDEBUG, so all the dump definitions were already enabled. Setting LLVM_ENABLE_DUMP=ON only makes sense for non-debug builds where LLVM_ENABLE_ASSERTIONS=OFF.

So, I think maintaining the default of OFF is the correct choice, but will set it to whatever you want.

Wait, I'm getting confused with all those discussions going in circles. I assumed we would also change the code inside llvm to simply test for LLVM_ENABLE_DUMP and not for !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP). But apparently we do not do that, in that case yes we can leave the default to "OFF" and the description to be "Enable dump functions even when assertions are disabled".

[hintonda]

In D38406#947502, @MatzeB wrote:

In D38406#947491, @hintonda wrote:

In D38406#947470, @MatzeB wrote:

Let's wait a bit to see if this is fine with people. It would probably be also nice to add the set(LLVM_ENABLE_DUMP OFF CACHE BOOL "") line to the varous caches in clang/cmake/caches that build llvm in release build types.

I don't mind changing the default, but the original default was OFF, and only flipped to ON if LLVM_ENABLE_ASSERTIONS was ON. But that had no affect, since enabling assertions removed -DNDEBUG and added -UNDEBUG, so all the dump definitions were already enabled. Setting LLVM_ENABLE_DUMP=ON only makes sense for non-debug builds where LLVM_ENABLE_ASSERTIONS=OFF.

So, I think maintaining the default of OFF is the correct choice, but will set it to whatever you want.

Wait, I'm getting confused with all those discussions going in circles. I assumed we would also change the code inside llvm to simply test for LLVM_ENABLE_DUMP and not for !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP). But apparently we do not do that, in that case yes we can leave the default to "OFF" and the description to be "Enable dump functions even when assertions are disabled".

That sounds much better. I'll make that change.

[hintonda]

• Set default back to OFF and update description.

[bogner]

At this point this is strictly better. Let's make this change and figure out where to go from here in tree.

CMakeLists.txt

396–398 ↗

(On Diff #125854)

Since everything checks both currently it doesn't actually have an effect, but I think we should leave this in place for now. It more accurately reflects our intent.

[bogner]

include/llvm/Config/llvm-config.h.cmake

17 ↗

(On Diff #125854)

Maybe this should say "provide dump methods, even in release builds". Most of the flags in this file are written in the "what does it do" style rather than the "how does it do it" style.

[hintonda]

CMakeLists.txt

396–398 ↗

(On Diff #125854)

I added this in D38306 based on the assumption that we could remove the NDEBUG test and just use the LLVM_ENABLE_DUMP test for dump definitions -- and other related functions.

However, that turned out to be a bad idea. So I think this should removed. Especially since it leaves the reader with the impression that you need to do it, which is false.

The only good thing about it is that it doesn't update the cache, so it's wrong but innocuous.

[bogner]

CMakeLists.txt

396–398 ↗

(On Diff #125854)

Okay, that makes sense.

llvm/trunk/CMakeLists.txt

 endif()
 option(LLVM_ENABLE_CXX1Y "Compile with C++1y enabled." OFF)
 option(LLVM_ENABLE_CXX1Z "Compile with C++1z enabled." OFF)
 option(LLVM_ENABLE_LIBCXX "Use libc++ if available." OFF)
 option(LLVM_ENABLE_LLD "Use lld as C and C++ linker." OFF)
 option(LLVM_ENABLE_PEDANTIC "Compile with pedantic enabled." ON)
 option(LLVM_ENABLE_WERROR "Fail and stop if a warning is triggered." OFF)
 
-option(LLVM_ENABLE_DUMP "Enable dump functions in release builds" OFF)
-
 if( NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" )
   option(LLVM_ENABLE_ASSERTIONS "Enable assertions" OFF)
+  option(LLVM_FORCE_ENABLE_DUMP "Enable dump functions in release builds" OFF)
 else()
   option(LLVM_ENABLE_ASSERTIONS "Enable assertions" ON)
+  option(LLVM_FORCE_ENABLE_DUMP "Enable dump functions in release builds" ON)
 endif()
 
-if( LLVM_ENABLE_ASSERTIONS )
+if( LLVM_ENABLE_ASSERTIONS OR LLVM_FORCE_ENABLE_DUMP )
   set(LLVM_ENABLE_DUMP ON)
 endif()
 
 option(LLVM_ENABLE_EXPENSIVE_CHECKS "Enable expensive checks" OFF)
 
 set(LLVM_ABI_BREAKING_CHECKS "WITH_ASSERTS" CACHE STRING
   "Enable abi-breaking checks.  Can be WITH_ASSERTS, FORCE_ON or FORCE_OFF.")
 

llvm/trunk/bindings/ocaml/llvm/llvm_ocaml.c

 
 /* lltype -> llcontext */
 CAMLprim LLVMContextRef llvm_type_context(LLVMTypeRef Ty) {
   return LLVMGetTypeContext(Ty);
 }
 
 /* lltype -> unit */
 CAMLprim value llvm_dump_type(LLVMTypeRef Val) {
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   LLVMDumpType(Val);
 #else
   caml_raise_with_arg(*caml_named_value("Llvm.FeatureDisabled"),
       caml_copy_string("dump"));
 #endif
   return Val_unit;
 }
 

llvm/trunk/include/llvm/Analysis/DominanceFrontier.h

public:
   /// this dominance frontier base. Otherwise return false.
   bool compare(DominanceFrontierBase &Other) const;
 
   /// print - Convert to human readable form
   ///
   void print(raw_ostream &OS) const;
 
   /// dump - Dump the dominance frontier to dbgs().
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   void dump() const;
 #endif
 };
 
 //===-------------------------------------
 /// DominanceFrontier Class - Concrete subclass of DominanceFrontierBase that is
 /// used to compute a forward dominator frontiers.
 ///

llvm/trunk/include/llvm/Analysis/DominanceFrontierImpl.h

for (const BlockT *BB : BBs) {
         BB->printAsOperand(OS, false);
       else
         OS << "<<exit node>>";
     }
     OS << '\n';
   }
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 template <class BlockT, bool IsPostDom>
 void DominanceFrontierBase<BlockT, IsPostDom>::dump() const {
   print(dbgs());
 }
 #endif
 
 template <class BlockT>
 const typename ForwardDominanceFrontierBase<BlockT>::DomSetType &

llvm/trunk/include/llvm/Analysis/RegionInfo.h

public:
   /// @brief Print the region.
   ///
   /// @param OS The output stream the Region is printed to.
   /// @param printTree Print also the tree of subregions.
   /// @param level The indentation level used for printing.
   void print(raw_ostream &OS, bool printTree = true, unsigned level = 0,
              PrintStyle Style = PrintNone) const;
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   /// @brief Print the region to stderr.
   void dump() const;
 #endif
 
   /// @brief Check if the region contains a BasicBlock.
   ///
   /// @param BB The BasicBlock that might be contained in this Region.
   /// @return True if the block is contained in the region otherwise false.

 public:
   RegionInfoBase(const RegionInfoBase &) = delete;
   RegionInfoBase &operator=(const RegionInfoBase &) = delete;
 
   static bool VerifyRegionInfo;
   static typename RegionT::PrintStyle printStyle;
 
   void print(raw_ostream &OS) const;
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   void dump() const;
 #endif
 
   void releaseMemory();
 
   /// @brief Get the smallest region that contains a BasicBlock.
   ///
   /// @param BB The basic block.

llvm/trunk/include/llvm/Analysis/RegionInfoImpl.h

if (print_tree) {
     for (const std::unique_ptr<RegionT> &R : *this)
       R->print(OS, print_tree, level + 1, Style);
   }
 
   if (Style != PrintNone)
     OS.indent(level * 2) << "} \n";
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 template <class Tr>
 void RegionBase<Tr>::dump() const {
   print(dbgs(), true, getDepth(), RegionInfoBase<Tr>::printStyle);
 }
 #endif
 
 template <class Tr>
 void RegionBase<Tr>::clearNodeCache() {

 
 template <class Tr>
 void RegionInfoBase<Tr>::print(raw_ostream &OS) const {
   OS << "Region tree:\n";
   TopLevelRegion->print(OS, true, 0, printStyle);
   OS << "End region tree\n";
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 template <class Tr>
 void RegionInfoBase<Tr>::dump() const { print(dbgs()); }
 #endif
 
 template <class Tr>
 void RegionInfoBase<Tr>::releaseMemory() {
   BBtoRegion.clear();
   if (TopLevelRegion)

llvm/trunk/include/llvm/CodeGen/TargetSchedule.h

unsigned getNumProcResourceKinds() const {
     return SchedModel.getNumProcResourceKinds();
   }
 
   /// \brief Get a processor resource by ID for convenience.
   const MCProcResourceDesc *getProcResource(unsigned PIdx) const {
     return SchedModel.getProcResource(PIdx);
   }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   const char *getResourceName(unsigned PIdx) const {
     if (!PIdx)
       return "MOps";
     return SchedModel.getProcResource(PIdx)->Name;
   }
 #endif
 
   using ProcResIter = const MCWriteProcResEntry *;

llvm/trunk/include/llvm/Config/config.h.cmake

 #cmakedefine01 LLVM_ENABLE_THREADS
 
 /* Define if zlib compression is available */
 #cmakedefine01 LLVM_ENABLE_ZLIB
 
 /* Has gcc/MSVC atomic intrinsics */
 #cmakedefine01 LLVM_HAS_ATOMICS
 
-/* Define if LLVM_ENABLE_DUMP is enabled */
-#cmakedefine LLVM_ENABLE_DUMP
-
 /* Host triple LLVM will be executed on */
 #cmakedefine LLVM_HOST_TRIPLE "${LLVM_HOST_TRIPLE}"
 
 /* Define if this is Unixish platform */
 #cmakedefine LLVM_ON_UNIX ${LLVM_ON_UNIX}
 
 /* Define if this is Win32ish platform */
 #cmakedefine LLVM_ON_WIN32 ${LLVM_ON_WIN32}

llvm/trunk/include/llvm/Config/llvm-config.h.cmake

 /*===------- llvm/Config/llvm-config.h - llvm configuration -------*- C -*-===*/
 /*                                                                            */
 /*                     The LLVM Compiler Infrastructure                       */
 /*                                                                            */
 /* This file is distributed under the University of Illinois Open Source      */
 /* License. See LICENSE.TXT for details.                                      */
 /*                                                                            */
 /*===----------------------------------------------------------------------===*/
 
 /* This file enumerates variables from the LLVM configuration so that they
    can be in exported headers and won't override package specific directives.
    This is a C header that can be included in the llvm-c headers. */
 
 #ifndef LLVM_CONFIG_H
 #define LLVM_CONFIG_H
 
+/* Defined in debug builds and release builds if LLVM_FORCE_ENABLE_DUMP
+   or LLVM_ENABLE_ASSERTIONS */
+#cmakedefine LLVM_ENABLE_DUMP
+
 /* Define if we link Polly to the tools */
 #cmakedefine LINK_POLLY_INTO_TOOLS
 
 /* Target triple LLVM will generate code for by default */
 #cmakedefine LLVM_DEFAULT_TARGET_TRIPLE "${LLVM_DEFAULT_TARGET_TRIPLE}"
 
 /* Define if threads enabled */
 #cmakedefine01 LLVM_ENABLE_THREADS

llvm/trunk/include/llvm/IR/Attributes.h

public:
   uint64_t getDereferenceableOrNullBytes() const;
   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
   std::string getAsString(bool InAttrGrp = false) const;
 
   using iterator = const Attribute *;
 
   iterator begin() const;
   iterator end() const;
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   void dump() const;
 #endif
 };
 
 //===----------------------------------------------------------------------===//
 /// \class
 /// \brief Provide DenseMapInfo for AttributeSet.
 template <> struct DenseMapInfo<AttributeSet> {

llvm/trunk/include/llvm/MC/MCSchedule.h

 #include <cassert>
 
 namespace llvm {
 
 struct InstrItinerary;
 
 /// Define a kind of processor resource that will be modeled by the scheduler.
 struct MCProcResourceDesc {
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   const char *Name;
 #endif
   unsigned NumUnits; // Number of resource of this kind
   unsigned SuperIdx; // Index of the resources kind that contains this kind.
 
   // Number of resources that may be buffered.
   //
   // Buffered resources (BufferSize != 0) may be consumed at some indeterminate

 /// Summarize the scheduling resources required for an instruction of a
 /// particular scheduling class.
 ///
 /// Defined as an aggregate struct for creating tables with initializer lists.
 struct MCSchedClassDesc {
   static const unsigned short InvalidNumMicroOps = UINT16_MAX;
   static const unsigned short VariantNumMicroOps = UINT16_MAX - 1;
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   const char* Name;
 #endif
   unsigned short NumMicroOps;
   bool     BeginGroup;
   bool     EndGroup;
   unsigned WriteProcResIdx; // First index into WriteProcResTable.
   unsigned NumWriteProcResEntries;
   unsigned WriteLatencyIdx; // First index into WriteLatencyTable.

llvm/trunk/include/llvm/Object/Wasm.h

public:
   }
 
   void print(raw_ostream &Out) const {
     Out << "Name=" << Name << ", Type=" << static_cast<int>(Type)
         << ", Flags=" << Flags << " ElemIndex=" << ElementIndex
         << ", ImportIndex=" << ImportIndex;
   }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
 #endif
 };
 
 struct WasmSection {
   WasmSection() = default;
 
   uint32_t Type = 0; // Section type (See below)

llvm/trunk/include/llvm/Support/Compiler.h

 #define LLVM_NO_SANITIZE(KIND) __attribute__((no_sanitize(KIND)))
 #else
 #define LLVM_NO_SANITIZE(KIND)
 #endif
 
 /// \brief Mark debug helper function definitions like dump() that should not be
 /// stripped from debug builds.
 /// Note that you should also surround dump() functions with
-/// `#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)` so they do always
-/// get stripped in release builds.
+/// `#ifdef LLVM_ENABLE_DUMP` so they do always get stripped in release builds
+/// unless asserts are enabled..
 // FIXME: Move this to a private config.h as it's not usable in public headers.
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 #define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED
 #else
 #define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE
 #endif
 
 /// \macro LLVM_PRETTY_FUNCTION
 /// \brief Gets a user-friendly looking function signature for the current scope
 /// using the best available method on each platform.  The exact format of the

llvm/trunk/lib/Analysis/AliasSetTracker.cpp

 void AliasSetTracker::print(raw_ostream &OS) const {
   OS << "Alias Set Tracker: " << AliasSets.size() << " alias sets for "
      << PointerMap.size() << " pointer values.\n";
   for (const AliasSet &AS : *this)
     AS.print(OS);
   OS << "\n";
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void AliasSet::dump() const { print(dbgs()); }
 LLVM_DUMP_METHOD void AliasSetTracker::dump() const { print(dbgs()); }
 #endif
 
 //===----------------------------------------------------------------------===//
 //                     ASTCallbackVH Class Implementation
 //===----------------------------------------------------------------------===//
 

llvm/trunk/lib/Analysis/BlockFrequencyInfoImpl.cpp

 #define DEBUG_TYPE "block-freq"
 
 ScaledNumber<uint64_t> BlockMass::toScaled() const {
   if (isFull())
     return ScaledNumber<uint64_t>(1, 0);
   return ScaledNumber<uint64_t>(getMass() + 1, -64);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void BlockMass::dump() const { print(dbgs()); }
 #endif
 
 static char getHexDigit(int N) {
   assert(N < 16);
   if (N < 10)
     return '0' + N;
   return 'a' + N - 10;

llvm/trunk/lib/Analysis/CallGraph.cpp

std::sort(Nodes.begin(), Nodes.end(),
 
     return RHS->getFunction() != nullptr;
   });
 
   for (CallGraphNode *CN : Nodes)
     CN->print(OS);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void CallGraph::dump() const { print(dbgs()); }
 #endif
 
 // removeFunctionFromModule - Unlink the function from this module, returning
 // it.  Because this removes the function from the module, the call graph node
 // is destroyed.  This is only valid if the function does not call any other
 // functions (ie, there are no edges in it's CGN).  The easiest way to do this
 // is to dropAllReferences before calling this.
for (const auto &I : *this) {
     if (Function *FI = I.second->getFunction())
       OS << "function '" << FI->getName() <<"'\n";
     else
       OS << "external node\n";
   }
   OS << '\n';
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void CallGraphNode::dump() const { print(dbgs()); }
 #endif
 
 /// removeCallEdgeFor - This method removes the edge in the node for the
 /// specified call site.  Note that this method takes linear time, so it
 /// should be used sparingly.
 void CallGraphNode::removeCallEdgeFor(CallSite CS) {
   for (CalledFunctionsVector::iterator I = CalledFunctions.begin(); ; ++I) {
if (!G) {
     OS << "No call graph has been built!\n";
     return;
   }
 
   // Just delegate.
   G->print(OS);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD
 void CallGraphWrapperPass::dump() const { print(dbgs(), nullptr); }
 #endif
 
 namespace {
 
 struct CallGraphPrinterLegacyPass : public ModulePass {
   static char ID; // Pass ID, replacement for typeid

llvm/trunk/lib/Analysis/DependenceAnalysis.cpp

 
 void DependenceInfo::Constraint::setEmpty() { Kind = Empty; }
 
 void DependenceInfo::Constraint::setAny(ScalarEvolution *NewSE) {
   SE = NewSE;
   Kind = Any;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 // For debugging purposes. Dumps the constraint out to OS.
 LLVM_DUMP_METHOD void DependenceInfo::Constraint::dump(raw_ostream &OS) const {
   if (isEmpty())
     OS << " Empty\n";
   else if (isAny())
     OS << " Any\n";
   else if (isPoint())
     OS << " Point is <" << *getX() << ", " << *getY() << ">\n";

llvm/trunk/lib/Analysis/DominanceFrontier.cpp

void DominanceFrontierWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequired<DominatorTreeWrapperPass>();
 }
 
 void DominanceFrontierWrapperPass::print(raw_ostream &OS, const Module *) const {
   DF.print(OS);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void DominanceFrontierWrapperPass::dump() const {
   print(dbgs());
 }
 #endif
 
 /// Handle invalidation explicitly.
 bool DominanceFrontier::invalidate(Function &F, const PreservedAnalyses &PA,
                                    FunctionAnalysisManager::Invalidator &) {

llvm/trunk/lib/Analysis/IVUsers.cpp

for (const IVStrideUse &IVUse : IVUses) {
     if (IVUse.getUser())
       IVUse.getUser()->print(OS);
     else
       OS << "Printing <null> User";
     OS << '\n';
   }
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void IVUsers::dump() const { print(dbgs()); }
 #endif
 
 void IVUsers::releaseMemory() {
   Processed.clear();
   IVUses.clear();
 }
 

llvm/trunk/lib/Analysis/InlineCost.cpp

bool CallAnalyzer::analyzeCall(CallSite CS) {
   if (NumVectorInstructions <= NumInstructions / 10)
     Threshold -= VectorBonus;
   else if (NumVectorInstructions <= NumInstructions / 2)
     Threshold -= VectorBonus/2;
 
   return Cost < std::max(1, Threshold);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 /// \brief Dump stats about this call's analysis.
 LLVM_DUMP_METHOD void CallAnalyzer::dump() {
 #define DEBUG_PRINT_STAT(x) dbgs() << "      " #x ": " << x << "\n"
   DEBUG_PRINT_STAT(NumConstantArgs);
   DEBUG_PRINT_STAT(NumConstantOffsetPtrArgs);
   DEBUG_PRINT_STAT(NumAllocaArgs);
   DEBUG_PRINT_STAT(NumConstantPtrCmps);
   DEBUG_PRINT_STAT(NumConstantPtrDiffs);

llvm/trunk/lib/Analysis/LazyCallGraph.cpp

LazyCallGraph::EdgeSequence &LazyCallGraph::Node::populateSlow() {
   return *Edges;
 }
 
 void LazyCallGraph::Node::replaceFunction(Function &NewF) {
   assert(F != &NewF && "Must not replace a function with itself!");
   F = &NewF;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void LazyCallGraph::Node::dump() const {
   dbgs() << *this << '\n';
 }
 #endif
 
 static bool isKnownLibFunction(Function &F, TargetLibraryInfo &TLI) {
   LibFunc LF;
 
LazyCallGraph &LazyCallGraph::operator=(LazyCallGraph &&G) {
   EntryEdges = std::move(G.EntryEdges);
   SCCBPA = std::move(G.SCCBPA);
   SCCMap = std::move(G.SCCMap);
   LibFunctions = std::move(G.LibFunctions);
   updateGraphPtrs();
   return *this;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void LazyCallGraph::SCC::dump() const {
   dbgs() << *this << '\n';
 }
 #endif
 
 #ifndef NDEBUG
 void LazyCallGraph::SCC::verify() {
   assert(OuterRefSCC && "Can't have a null RefSCC!");
bool LazyCallGraph::SCC::isAncestorOf(const SCC &TargetC) const {
   } while (!Worklist.empty());
 
   // No paths found.
   return false;
 }
 
 LazyCallGraph::RefSCC::RefSCC(LazyCallGraph &G) : G(&G) {}
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void LazyCallGraph::RefSCC::dump() const {
   dbgs() << *this << '\n';
 }
 #endif
 
 #ifndef NDEBUG
 void LazyCallGraph::RefSCC::verify() {
   assert(G && "Can't have a null graph!");

llvm/trunk/lib/Analysis/LoopInfo.cpp

 BasicBlock *Loop::getUniqueExitBlock() const {
   SmallVector<BasicBlock *, 8> UniqueExitBlocks;
   getUniqueExitBlocks(UniqueExitBlocks);
   if (UniqueExitBlocks.size() == 1)
     return UniqueExitBlocks[0];
   return nullptr;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void Loop::dump() const { print(dbgs()); }
 
 LLVM_DUMP_METHOD void Loop::dumpVerbose() const {
   print(dbgs(), /*Depth=*/0, /*Verbose=*/true);
 }
 #endif
 
 //===----------------------------------------------------------------------===//

llvm/trunk/lib/Analysis/MemorySSA.cpp

if (Accesses->empty())
     PerBlockAccesses.erase(AccessIt);
 }
 
 void MemorySSA::print(raw_ostream &OS) const {
   MemorySSAAnnotatedWriter Writer(this);
   F.print(OS, &Writer);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MemorySSA::dump() const { print(dbgs()); }
 #endif
 
 void MemorySSA::verifyMemorySSA() const {
   verifyDefUses(F);
   verifyDomination(F);
   verifyOrdering(F);
   Walker->verify(this);
if (UO && UO->getID())
     OS << UO->getID();
   else
     OS << LiveOnEntryStr;
   OS << ')';
 }
 
 void MemoryAccess::dump() const {
 // Cannot completely remove virtual function even in release mode.
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   print(dbgs());
   dbgs() << "\n";
 #endif
 }
 
 char MemorySSAPrinterLegacyPass::ID = 0;
 
 MemorySSAPrinterLegacyPass::MemorySSAPrinterLegacyPass() : FunctionPass(ID) {

llvm/trunk/lib/Analysis/PHITransAddr.cpp

if (Inst->getOpcode() == Instruction::Add &&
     return true;
 
   //   cerr << "MEMDEP: Could not PHI translate: " << *Pointer;
   //   if (isa<BitCastInst>(PtrInst) || isa<GetElementPtrInst>(PtrInst))
   //     cerr << "OP:\t\t\t\t" << *PtrInst->getOperand(0);
   return false;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void PHITransAddr::dump() const {
   if (!Addr) {
     dbgs() << "PHITransAddr: null\n";
     return;
   }
   dbgs() << "PHITransAddr: " << *Addr << "\n";
   for (unsigned i = 0, e = InstInputs.size(); i != e; ++i)
     dbgs() << "  Input #" << i << " is " << *InstInputs[i] << "\n";

llvm/trunk/lib/Analysis/RegionInfo.cpp

void RegionInfoPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<PostDominatorTreeWrapperPass>();
   AU.addRequired<DominanceFrontierWrapperPass>();
 }
 
 void RegionInfoPass::print(raw_ostream &OS, const Module *) const {
   RI.print(OS);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void RegionInfoPass::dump() const {
   RI.dump();
 }
 #endif
 
 char RegionInfoPass::ID = 0;
 
 INITIALIZE_PASS_BEGIN(RegionInfoPass, "regions",

llvm/trunk/lib/Analysis/ScalarEvolution.cpp

 //===----------------------------------------------------------------------===//
 //                           SCEV class definitions
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Implementation of the SCEV class.
 //
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void SCEV::dump() const {
   print(dbgs());
   dbgs() << '\n';
 }
 #endif
 
 void SCEV::print(raw_ostream &OS) const {
   switch (static_cast<SCEVTypes>(getSCEVType())) {

llvm/trunk/lib/Analysis/Trace.cpp

void Trace::print(raw_ostream &O) const {
   for (const_iterator i = begin(), e = end(); i != e; ++i) {
     O << "; ";
     (*i)->printAsOperand(O, true, getModule());
     O << "\n";
   }
   O << "; Trace parent function: \n" << *F;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 /// dump - Debugger convenience method; writes trace to standard error
 /// output stream.
 LLVM_DUMP_METHOD void Trace::dump() const {
   print(dbgs());
 }
 #endif

llvm/trunk/lib/Bitcode/Writer/ValueEnumerator.cpp

unsigned ValueEnumerator::getValueID(const Value *V) const {
   if (auto *MD = dyn_cast<MetadataAsValue>(V))
     return getMetadataID(MD->getMetadata());
 
   ValueMapType::const_iterator I = ValueMap.find(V);
   assert(I != ValueMap.end() && "Value not in slotcalculator!");
   return I->second-1;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void ValueEnumerator::dump() const {
   print(dbgs(), ValueMap, "Default");
   dbgs() << '\n';
   print(dbgs(), MetadataMap, "MetaData");
   dbgs() << '\n';
 }
 #endif
 

llvm/trunk/lib/CodeGen/AsmPrinter/DIE.cpp

for (unsigned i = 0, N = Data.size(); i < N; ++i) {
 
     if (Data[i].getForm() == dwarf::DW_FORM_implicit_const)
       O << " " << Data[i].getValue();
 
     O << '\n';
   }
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void DIEAbbrev::dump() const {
   print(dbgs());
 }
 #endif
 
 //===----------------------------------------------------------------------===//
 // DIEAbbrevSet Implementation
 //===----------------------------------------------------------------------===//
void DIE::print(raw_ostream &O, unsigned IndentCount) const {
   IndentCount -= 2;
 
   for (const auto &Child : children())
     Child.print(O, IndentCount + 4);
 
   O << "\n";
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void DIE::dump() const {
   print(dbgs());
 }
 #endif
 
 unsigned DIE::computeOffsetsAndAbbrevs(const AsmPrinter *AP,
                                        DIEAbbrevSet &AbbrevSet,
                                        unsigned CUOffset) {

 #define HANDLE_DIEVALUE(T)                                                     \
   case is##T:                                                                  \
     getDIE##T().print(O);                                                      \
     break;
 #include "llvm/CodeGen/DIEValue.def"
   }
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void DIEValue::dump() const {
   print(dbgs());
 }
 #endif
 
 //===----------------------------------------------------------------------===//
 // DIEInteger Implementation
 //===----------------------------------------------------------------------===//

llvm/trunk/lib/CodeGen/AsmPrinter/DebugLocEntry.h

struct Value {
     int64_t getInt() const { return Constant.Int; }
     const ConstantFP *getConstantFP() const { return Constant.CFP; }
     const ConstantInt *getConstantInt() const { return Constant.CIP; }
     MachineLocation getLoc() const { return Loc; }
     bool isFragment() const { return getExpression()->isFragment(); }
     const DIExpression *getExpression() const { return Expression; }
     friend bool operator==(const Value &, const Value &);
     friend bool operator<(const Value &, const Value &);
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
     LLVM_DUMP_METHOD void dump() const {
       if (isLocation()) {
         llvm::dbgs() << "Loc = { reg=" << Loc.getReg() << " ";
         if (Loc.isIndirect())
           llvm::dbgs() << "+0";
         llvm::dbgs() << "} ";
       }
       else if (isConstantInt())

llvm/trunk/lib/CodeGen/BranchRelaxation.cpp

for (MachineBasicBlock &MBB : *MF) {
     assert(BlockInfo[Num].Offset % (1u << Align) == 0);
     assert(!Num || BlockInfo[PrevNum].postOffset(MBB) <= BlockInfo[Num].Offset);
     assert(BlockInfo[Num].Size == computeBlockSize(MBB));
     PrevNum = Num;
   }
 #endif
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 /// print block size and offset information - debugging
 LLVM_DUMP_METHOD void BranchRelaxation::dumpBBs() {
   for (auto &MBB : *MF) {
     const BasicBlockInfo &BBI = BlockInfo[MBB.getNumber()];
     dbgs() << format("BB#%u\toffset=%08x\t", MBB.getNumber(), BBI.Offset)
            << format("size=%#x\n", BBI.Size);
   }
 }

llvm/trunk/lib/CodeGen/CodeGenPrepare.cpp

 
 #ifndef NDEBUG
 static inline raw_ostream &operator<<(raw_ostream &OS, const ExtAddrMode &AM) {
   AM.print(OS);
   return OS;
 }
 #endif
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 void ExtAddrMode::print(raw_ostream &OS) const {
   bool NeedPlus = false;
   OS << "[";
   if (BaseGV) {
     OS << (NeedPlus ? " + " : "")
        << "GV:";
     BaseGV->printAsOperand(OS, /*PrintType=*/false);
     NeedPlus = true;

llvm/trunk/lib/CodeGen/GlobalISel/RegBankSelect.cpp

bool RegBankSelect::MappingCost::operator<(const MappingCost &Cost) const {
   return ThisScaledCost < OtherScaledCost;
 }
 
 bool RegBankSelect::MappingCost::operator==(const MappingCost &Cost) const {
   return LocalCost == Cost.LocalCost && NonLocalCost == Cost.NonLocalCost &&
          LocalFreq == Cost.LocalFreq;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void RegBankSelect::MappingCost::dump() const {
   print(dbgs());
   dbgs() << '\n';
 }
 #endif
 
 void RegBankSelect::MappingCost::print(raw_ostream &OS) const {
   if (*this == ImpossibleCost()) {

llvm/trunk/lib/CodeGen/GlobalISel/RegisterBank.cpp

bool RegisterBank::operator==(const RegisterBank &OtherRB) const {
   // There must be only one instance of a given register bank alive
   // for the whole compilation.
   // The RegisterBankInfo is supposed to enforce that.
   assert((OtherRB.getID() != getID() || &OtherRB == this) &&
          "ID does not uniquely identify a RegisterBank");
   return &OtherRB == this;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void RegisterBank::dump(const TargetRegisterInfo *TRI) const {
   print(dbgs(), /* IsForDebug */ true, TRI);
 }
 #endif
 
 void RegisterBank::print(raw_ostream &OS, bool IsForDebug,
                          const TargetRegisterInfo *TRI) const {
   OS << getName();

llvm/trunk/lib/CodeGen/GlobalISel/RegisterBankInfo.cpp

unsigned RegisterBankInfo::getSizeInBits(unsigned Reg,
   }
   assert(RC && "Unable to deduce the register class");
   return TRI.getRegSizeInBits(*RC);
 }
 
 //------------------------------------------------------------------------------
 // Helper classes implementation.
 //------------------------------------------------------------------------------
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void RegisterBankInfo::PartialMapping::dump() const {
   print(dbgs());
   dbgs() << '\n';
 }
 #endif
 
 bool RegisterBankInfo::PartialMapping::verify() const {
   assert(RegBank && "Register bank not set");
for (const RegisterBankInfo::PartialMapping &PartMap : *this) {
     ValueMask ^= PartMapMask;
     assert((ValueMask & PartMapMask) == PartMapMask &&
            "Some partial mappings overlap");
   }
   assert(ValueMask.isAllOnesValue() && "Value is not fully mapped");
   return true;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void RegisterBankInfo::ValueMapping::dump() const {
   print(dbgs());
   dbgs() << '\n';
 }
 #endif
 
 void RegisterBankInfo::ValueMapping::print(raw_ostream &OS) const {
   OS << "#BreakDown: " << NumBreakDowns << " ";
for (unsigned Idx = 0; Idx < NumOperands; ++Idx) {
     // This size must match what the mapping expects.
     assert(MOMapping.verify(getSizeInBits(
                Reg, MF.getRegInfo(), *MF.getSubtarget().getRegisterInfo())) &&
            "Value mapping is invalid");
   }
   return true;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void RegisterBankInfo::InstructionMapping::dump() const {
   print(dbgs());
   dbgs() << '\n';
 }
 #endif
 
 void RegisterBankInfo::InstructionMapping::print(raw_ostream &OS) const {
   OS << "ID: " << getID() << " Cost: " << getCost() << " Mapping: ";
iterator_range<SmallVectorImpl<unsigned>::const_iterator> Res =
       make_range(&NewVRegs[StartIdx], End);
 #ifndef NDEBUG
   for (unsigned VReg : Res)
     assert((VReg || ForDebug) && "Some registers are uninitialized");
 #endif
   return Res;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void RegisterBankInfo::OperandsMapper::dump() const {
   print(dbgs(), true);
   dbgs() << '\n';
 }
 #endif
 
 void RegisterBankInfo::OperandsMapper::print(raw_ostream &OS,
                                              bool ForDebug) const {

llvm/trunk/lib/CodeGen/InlineSpiller.cpp

bool InlineSpiller::coalesceStackAccess(MachineInstr *MI, unsigned Reg) {
   } else {
     ++NumSpillsRemoved;
     --NumSpills;
   }
 
   return true;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD
 // Dump the range of instructions from B to E with their slot indexes.
 static void dumpMachineInstrRangeWithSlotIndex(MachineBasicBlock::iterator B,
                                                MachineBasicBlock::iterator E,
                                                LiveIntervals const &LIS,
                                                const char *const header,
                                                unsigned VReg =0) {
   char NextLine = '\n';

llvm/trunk/lib/CodeGen/LexicalScopes.cpp

for (auto &I : *MBB) {
     if (const DILocation *IDL = I.getDebugLoc())
       if (LexicalScope *IScope = getOrCreateLexicalScope(IDL))
         if (Scope->dominates(IScope))
           return true;
   }
   return Result;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void LexicalScope::dump(unsigned Indent) const {
   raw_ostream &err = dbgs();
   err.indent(Indent);
   err << "DFSIn: " << DFSIn << " DFSOut: " << DFSOut << "\n";
   const MDNode *N = Desc;
   err.indent(Indent);
   N->dump();
   if (AbstractScope)

llvm/trunk/lib/CodeGen/LiveDebugValues.cpp

unsigned isDescribedByReg() const {
         return Loc.RegNo;
       return 0;
     }
 
     /// Determine whether the lexical scope of this value's debug location
     /// dominates MBB.
     bool dominates(MachineBasicBlock &MBB) const { return UVS.dominates(&MBB); }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
     LLVM_DUMP_METHOD void dump() const { MI.dump(); }
 #endif
 
     bool operator==(const VarLoc &Other) const {
       return Var == Other.Var && Loc.Hash == Other.Loc.Hash;
     }
 
     /// This operator guarantees that VarLocs are sorted by Variable first.

llvm/trunk/lib/CodeGen/LiveDebugVariables.cpp

public:
   /// emitDebugValues - Recreate DBG_VALUE instruction from data structures.
   void emitDebugValues(VirtRegMap *VRM);
 
   void print(raw_ostream&);
 };
 
 } // end anonymous namespace
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 static void printDebugLoc(const DebugLoc &DL, raw_ostream &CommentOS,
                           const LLVMContext &Ctx) {
   if (!DL)
     return;
 
   auto *Scope = cast<DIScope>(DL.getScope());
   // Omit the directory, because it's likely to be long and uninteresting.
   CommentOS << Scope->getFilename();
void LiveDebugVariables::emitDebugValues(VirtRegMap *VRM) {
   if (pImpl)
     static_cast<LDVImpl*>(pImpl)->emitDebugValues(VRM);
 }
 
 bool LiveDebugVariables::doInitialization(Module &M) {
   return Pass::doInitialization(M);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void LiveDebugVariables::dump() const {
   if (pImpl)
     static_cast<LDVImpl*>(pImpl)->print(dbgs());
 }
 #endif

llvm/trunk/lib/CodeGen/LiveInterval.cpp

for (const MachineOperand &MO : MRI.def_operands(reg)) {
     }
   }
 }
 
 raw_ostream& llvm::operator<<(raw_ostream& OS, const LiveRange::Segment &S) {
   return OS << '[' << S.start << ',' << S.end << ':' << S.valno->id << ')';
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void LiveRange::Segment::dump() const {
   dbgs() << *this << '\n';
 }
 #endif
 
 void LiveRange::print(raw_ostream &OS) const {
   if (empty())
     OS << "EMPTY";

 void LiveInterval::print(raw_ostream &OS) const {
   OS << PrintReg(reg) << ' ';
   super::print(OS);
   // Print subranges
   for (const SubRange &SR : subranges())
     OS << SR;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void LiveRange::dump() const {
   dbgs() << *this << '\n';
 }
 
 LLVM_DUMP_METHOD void LiveInterval::SubRange::dump() const {
   dbgs() << *this << '\n';
 }
 

 //   1, and there are no overlapping segments.
 //
 // The segments in Spills are not ordered with respect to the segments in area
 // 1. They need to be merged.
 //
 // When they exist, Spills.back().start <= LastStart,
 //                 and WriteI[-1].start <= LastStart.
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 void LiveRangeUpdater::print(raw_ostream &OS) const {
   if (!isDirty()) {
     if (LR)
       OS << "Clean updater: " << *LR << '\n';
     else
       OS << "Null updater.\n";
     return;
   }

llvm/trunk/lib/CodeGen/LiveIntervalAnalysis.cpp

void LiveIntervals::print(raw_ostream &OS, const Module* ) const {
   printInstrs(OS);
 }
 
 void LiveIntervals::printInstrs(raw_ostream &OS) const {
   OS << "********** MACHINEINSTRS **********\n";
   MF->print(OS, Indexes);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void LiveIntervals::dumpInstrs() const {
   printInstrs(dbgs());
 }
 #endif
 
 LiveInterval* LiveIntervals::createInterval(unsigned reg) {
   float Weight = TargetRegisterInfo::isPhysicalRegister(reg) ? huge_valf : 0.0F;
   return new LiveInterval(reg, Weight);

llvm/trunk/lib/CodeGen/LivePhysRegs.cpp

if (empty()) {
     return;
   }
 
   for (const_iterator I = begin(), E = end(); I != E; ++I)
     OS << " " << PrintReg(*I, TRI);
   OS << "\n";
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void LivePhysRegs::dump() const {
   dbgs() << "  " << *this;
 }
 #endif
 
 bool LivePhysRegs::available(const MachineRegisterInfo &MRI,
                              unsigned Reg) const {
   if (LiveRegs.count(Reg))

llvm/trunk/lib/CodeGen/LiveVariables.cpp

 MachineInstr *
 LiveVariables::VarInfo::findKill(const MachineBasicBlock *MBB) const {
   for (unsigned i = 0, e = Kills.size(); i != e; ++i)
     if (Kills[i]->getParent() == MBB)
       return Kills[i];
   return nullptr;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void LiveVariables::VarInfo::dump() const {
   dbgs() << "  Alive in blocks: ";
   for (SparseBitVector<>::iterator I = AliveBlocks.begin(),
            E = AliveBlocks.end(); I != E; ++I)
     dbgs() << *I << ", ";
   dbgs() << "\n  Killed by:";
   if (Kills.empty())
     dbgs() << " No instructions.\n";

llvm/trunk/lib/CodeGen/MachineBasicBlock.cpp

 
 bool MachineBasicBlock::hasEHPadSuccessor() const {
   for (const_succ_iterator I = succ_begin(), E = succ_end(); I != E; ++I)
     if ((*I)->isEHPad())
       return true;
   return false;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MachineBasicBlock::dump() const {
   print(dbgs());
 }
 #endif
 
 bool MachineBasicBlock::isLegalToHoistInto() const {
   if (isReturnBlock() || hasEHPadSuccessor())
     return false;

llvm/trunk/lib/CodeGen/MachineFrameInfo.cpp

if (i < NumFixedObjects || SO.SPOffset != -1) {
       else if (Off < 0)
         OS << Off;
       OS << "]";
     }
     OS << "\n";
   }
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MachineFrameInfo::dump(const MachineFunction &MF) const {
   print(MF, dbgs());
 }
 #endif

llvm/trunk/lib/CodeGen/MachineFunction.cpp

 
 const char *MachineFunction::createExternalSymbolName(StringRef Name) {
   char *Dest = Allocator.Allocate<char>(Name.size() + 1);
   std::copy(Name.begin(), Name.end(), Dest);
   Dest[Name.size()] = 0;
   return Dest;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MachineFunction::dump() const {
   print(dbgs());
 }
 #endif
 
 StringRef MachineFunction::getName() const {
   assert(getFunction() && "No function!");
   return getFunction()->getName();
for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) {
     OS << "  jt#" << i << ": ";
     for (unsigned j = 0, f = JumpTables[i].MBBs.size(); j != f; ++j)
       OS << " BB#" << JumpTables[i].MBBs[j]->getNumber();
   }
 
   OS << '\n';
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MachineJumpTableInfo::dump() const { print(dbgs()); }
 #endif
 
 //===----------------------------------------------------------------------===//
 //  MachineConstantPool implementation
 //===----------------------------------------------------------------------===//
 
 void MachineConstantPoolValue::anchor() {}
if (Constants[i].isMachineConstantPoolEntry())
       Constants[i].Val.MachineCPVal->print(OS);
     else
       Constants[i].Val.ConstVal->printAsOperand(OS, /*PrintType=*/false);
     OS << ", align=" << Constants[i].getAlignment();
     OS << "\n";
   }
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MachineConstantPool::dump() const { print(dbgs()); }
 #endif

llvm/trunk/lib/CodeGen/MachineInstr.cpp

OS << '<' << (CmpInst::isIntPredicate(Pred) ? "intpred" : "floatpred")
        << CmpInst::getPredicateName(Pred) << '>';
     break;
   }
   }
   if (unsigned TF = getTargetFlags())
     OS << "[TF=" << TF << ']';
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MachineOperand::dump() const {
   dbgs() << *this << '\n';
 }
 #endif
 
 //===----------------------------------------------------------------------===//
 // MachineMemOperand Implementation
 //===----------------------------------------------------------------------===//
void MachineInstr::copyImplicitOps(MachineFunction &MF,
   for (unsigned i = MI.getDesc().getNumOperands(), e = MI.getNumOperands();
        i != e; ++i) {
     const MachineOperand &MO = MI.getOperand(i);
     if ((MO.isReg() && MO.isImplicit()) || MO.isRegMask())
       addOperand(MF, MO);
   }
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MachineInstr::dump() const {
   dbgs() << "  ";
   print(dbgs());
 }
 #endif
 
 void MachineInstr::print(raw_ostream &OS, bool SkipOpers, bool SkipDebugLoc,
                          const TargetInstrInfo *TII) const {

llvm/trunk/lib/CodeGen/MachineLoopInfo.cpp

if (S == HB)
       continue;
     MachineLoop *T = getLoopFor(S);
     if (T && T->getHeader() == S)
       return nullptr;
   }
   return Preheader;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MachineLoop::dump() const {
   print(dbgs());
 }
 #endif

llvm/trunk/lib/CodeGen/MachinePipeliner.cpp

public:
   void print(raw_ostream &os) const {
     os << "Num nodes " << size() << " rec " << RecMII << " mov " << MaxMOV
        << " depth " << MaxDepth << " col " << Colocate << "\n";
     for (const auto &I : Nodes)
       os << "   SU(" << I->NodeNum << ") " << *(I->getInstr());
     os << "\n";
   }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
 #endif
 };
 
 /// This class repesents the scheduled code.  The main data structure is a
 /// map from scheduled cycle to instructions.  During scheduling, the
 /// data structure explicitly represents all stages/iterations.   When
 /// the algorithm finshes, the schedule is collapsed into a single stage,
for (int Cycle = getFirstCycle(), E = getFinalCycle(); Cycle <= E; ++Cycle) {
     cycleInstrs.swap(newOrderZC);
     cycleInstrs.insert(cycleInstrs.end(), newOrderI.begin(), newOrderI.end());
     SSD->fixupRegisterOverlaps(cycleInstrs);
   }
 
   DEBUG(dump(););
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 /// Print the schedule information to the given output.
 void SMSchedule::print(raw_ostream &os) const {
   // Iterate over each cycle.
   for (int cycle = getFirstCycle(); cycle <= getFinalCycle(); ++cycle) {
     // Iterate over each instruction in the cycle.
     const_sched_iterator cycleInstrs = ScheduledInstrs.find(cycle);
     for (SUnit *CI : cycleInstrs->second) {
       os << "cycle " << cycle << " (" << stageScheduled(CI) << ") ";

llvm/trunk/lib/CodeGen/MachineRegionInfo.cpp

void MachineRegionInfoPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<MachineDominanceFrontier>();
   MachineFunctionPass::getAnalysisUsage(AU);
 }
 
 void MachineRegionInfoPass::print(raw_ostream &OS, const Module *) const {
   RI.print(OS);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MachineRegionInfoPass::dump() const {
   RI.dump();
 }
 #endif
 
 char MachineRegionInfoPass::ID = 0;
 char &MachineRegionInfoPassID = MachineRegionInfoPass::ID;
 

llvm/trunk/lib/CodeGen/MachineRegisterInfo.cpp

 
 LaneBitmask MachineRegisterInfo::getMaxLaneMaskForVReg(unsigned Reg) const {
   // Lane masks are only defined for vregs.
   assert(TargetRegisterInfo::isVirtualRegister(Reg));
   const TargetRegisterClass &TRC = *getRegClass(Reg);
   return TRC.getLaneMask();
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MachineRegisterInfo::dumpUses(unsigned Reg) const {
   for (MachineInstr &I : use_instructions(Reg))
     I.dump();
 }
 #endif
 
 void MachineRegisterInfo::freezeReservedRegs(const MachineFunction &MF) {
   ReservedRegs = getTargetRegisterInfo()->getReservedRegs(MF);

llvm/trunk/lib/CodeGen/MachineScheduler.cpp

#endif
   }
   Scheduler.finalizeSchedule();
 }
 
 void MachineSchedulerBase::print(raw_ostream &O, const Module* m) const {
   // unimplemented
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void ReadyQueue::dump() const {
   dbgs() << "Queue " << Name << ": ";
   for (const SUnit *SU : Queue)
     dbgs() << SU->NodeNum << " ";
   dbgs() << "\n";
 }
 #endif
 
for (std::vector<std::pair<MachineInstr *, MachineInstr *>>::iterator
     BB->splice(++OrigPrevMI, BB, DbgValue);
     if (OrigPrevMI == std::prev(RegionEnd))
       RegionEnd = DbgValue;
   }
   DbgValues.clear();
   FirstDbgValue = nullptr;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void ScheduleDAGMI::dumpSchedule() const {
   for (MachineBasicBlock::iterator MI = begin(), ME = end(); MI != ME; ++MI) {
     if (SUnit *SU = getSUnit(&(*MI)))
       SU->dump(this);
     else
       dbgs() << "Missing SUnit\n";
   }
 }
//           "permanent hazard");
   DEBUG(Pending.dump());
   DEBUG(Available.dump());
 
   if (Available.size() == 1)
     return *Available.begin();
   return nullptr;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 // This is useful information to dump after bumpNode.
 // Note that the Queue contents are more useful before pickNodeFromQueue.
 LLVM_DUMP_METHOD void SchedBoundary::dumpScheduledState() const {
   unsigned ResFactor;
   unsigned ResCount;
   if (ZoneCritResIdx) {
     ResFactor = SchedModel->getResourceFactor(ZoneCritResIdx);
     ResCount = getResourceCount(ZoneCritResIdx);
if (ForceTopDown.getNumOccurrences() > 0) {
     RegionPolicy.OnlyTopDown = ForceTopDown;
     if (RegionPolicy.OnlyTopDown)
       RegionPolicy.OnlyBottomUp = false;
   }
 }
 
 void GenericScheduler::dumpPolicy() const {
   // Cannot completely remove virtual function even in release mode.
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   dbgs() << "GenericScheduler RegionPolicy: "
          << " ShouldTrackPressure=" << RegionPolicy.ShouldTrackPressure
          << " OnlyTopDown=" << RegionPolicy.OnlyTopDown
          << " OnlyBottomUp=" << RegionPolicy.OnlyBottomUp
          << "\n";
 #endif
 }
 

llvm/trunk/lib/CodeGen/PostRASchedulerList.cpp

void SchedulePostRATDList::exitRegion() {
   DEBUG({
       dbgs() << "*** Final schedule ***\n";
       dumpSchedule();
       dbgs() << '\n';
     });
   ScheduleDAGInstrs::exitRegion();
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 /// dumpSchedule - dump the scheduled Sequence.
 LLVM_DUMP_METHOD void SchedulePostRATDList::dumpSchedule() const {
   for (unsigned i = 0, e = Sequence.size(); i != e; i++) {
     if (SUnit *SU = Sequence[i])
       SU->dump(this);
     else
       dbgs() << "**** NOOP ****\n";
   }

llvm/trunk/lib/CodeGen/RegAllocPBQP.cpp

return Printable([NId, &G](raw_ostream &OS) {
     const MachineRegisterInfo &MRI = G.getMetadata().MF.getRegInfo();
     const TargetRegisterInfo *TRI = MRI.getTargetRegisterInfo();
     unsigned VReg = G.getNodeMetadata(NId).getVReg();
     const char *RegClassName = TRI->getRegClassName(MRI.getRegClass(VReg));
     OS << NId << " (" << RegClassName << ':' << PrintReg(VReg, TRI) << ')';
   });
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void PBQP::RegAlloc::PBQPRAGraph::dump(raw_ostream &OS) const {
   for (auto NId : nodeIds()) {
     const Vector &Costs = getNodeCosts(NId);
     assert(Costs.getLength() != 0 && "Empty vector in graph.");
     OS << PrintNodeInfo(NId, *this) << ": " << Costs << '\n';
   }
   OS << '\n';
 

llvm/trunk/lib/CodeGen/RegisterPressure.cpp

static void decreaseSetPressure(std::vector<unsigned> &CurrSetPressure,
   PSetIterator PSetI = MRI.getPressureSets(Reg);
   unsigned Weight = PSetI.getWeight();
   for (; PSetI.isValid(); ++PSetI) {
     assert(CurrSetPressure[*PSetI] >= Weight && "register pressure underflow");
     CurrSetPressure[*PSetI] -= Weight;
   }
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD
 void llvm::dumpRegSetPressure(ArrayRef<unsigned> SetPressure,
                               const TargetRegisterInfo *TRI) {
   bool Empty = true;
   for (unsigned i = 0, e = SetPressure.size(); i < e; ++i) {
     if (SetPressure[i] != 0) {
       dbgs() << TRI->getRegPressureSetName(i) << "=" << SetPressure[i] << '\n';
       Empty = false;

llvm/trunk/lib/CodeGen/SafeStackColoring.cpp

for (auto IT : BlockLiveness) {
     }
 
     for (unsigned AllocaNo = 0; AllocaNo < NumAllocas; ++AllocaNo)
       if (Started.test(AllocaNo))
         LiveRanges[AllocaNo].AddRange(Start[AllocaNo], BBEnd);
   }
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void StackColoring::dumpAllocas() {
   dbgs() << "Allocas:\n";
   for (unsigned AllocaNo = 0; AllocaNo < NumAllocas; ++AllocaNo)
     dbgs() << "  " << AllocaNo << ": " << *Allocas[AllocaNo] << "\n";
 }
 
 LLVM_DUMP_METHOD void StackColoring::dumpBlockLiveness() {
   dbgs() << "Block liveness:\n";

llvm/trunk/lib/CodeGen/ScheduleDAG.cpp

for (SUnit::pred_iterator I = std::next(BestI), E = Preds.end(); I != E;
        ++I) {
     if (I->getKind() == SDep::Data && I->getSUnit()->getDepth() > MaxDepth)
       BestI = I;
   }
   if (BestI != Preds.begin())
     std::swap(*Preds.begin(), *BestI);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD
 raw_ostream &SUnit::print(raw_ostream &OS,
                           const SUnit *Entry, const SUnit *Exit) const {
   if (this == Entry)
     OS << "EntrySU";
   else if (this == Exit)
     OS << "ExitSU";
   else

llvm/trunk/lib/CodeGen/ScheduleDAGInstrs.cpp

static unsigned getReductionSize() {
   // Always reduce a huge region with half of the elements, except
   // when user sets this number explicitly.
   if (ReductionSize.getNumOccurrences() == 0)
     return HugeRegion / 2;
   return ReductionSize;
 }
 
 static void dumpSUList(ScheduleDAGInstrs::SUList &L) {
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   dbgs() << "{ ";
   for (const SUnit *su : L) {
     dbgs() << "SU(" << su->NodeNum << ")";
     if (su != L.back())
       dbgs() << ", ";
   }
   dbgs() << "}\n";
 #endif
if (!MI.isBundled()) {
         --I;
       } while(I != First);
     }
   }
 }
 
 void ScheduleDAGInstrs::dumpNode(const SUnit *SU) const {
   // Cannot completely remove virtual function even in release mode.
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   SU->getInstr()->dump();
 #endif
 }
 
 std::string ScheduleDAGInstrs::getGraphNodeLabel(const SUnit *SU) const {
   std::string s;
   raw_string_ostream oss(s);
   if (SU == &EntrySU)
void SchedDFSResult::scheduleTree(unsigned SubtreeID) {
   for (const Connection &C : SubtreeConnections[SubtreeID]) {
     SubtreeConnectLevels[C.TreeID] =
       std::max(SubtreeConnectLevels[C.TreeID], C.Level);
     DEBUG(dbgs() << "  Tree: " << C.TreeID
           << " @" << SubtreeConnectLevels[C.TreeID] << '\n');
   }
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void ILPValue::print(raw_ostream &OS) const {
   OS << InstrCount << " / " << Length << " = ";
   if (!Length)
     OS << "BADILP";
   else
     OS << format("%g", ((double)InstrCount / Length));
 }
 

llvm/trunk/lib/CodeGen/ScoreboardHazardRecognizer.cpp

 }
 
 void ScoreboardHazardRecognizer::Reset() {
   IssueCount = 0;
   RequiredScoreboard.reset();
   ReservedScoreboard.reset();
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void ScoreboardHazardRecognizer::Scoreboard::dump() const {
   dbgs() << "Scoreboard:\n";
 
   unsigned last = Depth - 1;
   while ((last > 0) && ((*this)[last] == 0))
     last--;
 
   for (unsigned i = 0; i <= last; i++) {

llvm/trunk/lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp

public:
   SUnit *pop() override {
     if (Queue.empty()) return nullptr;
 
     SUnit *V = popFromQueue(Queue, Picker, scheduleDAG);
     V->NodeQueueId = 0;
     return V;
   }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   LLVM_DUMP_METHOD void dump(ScheduleDAG *DAG) const override {
     // Emulate pop() without clobbering NodeQueueIds.
     std::vector<SUnit *> DumpQueue = Queue;
     SF DumpPicker = Picker;
     while (!DumpQueue.empty()) {
       SUnit *SU = popFromQueue(DumpQueue, DumpPicker, scheduleDAG);
       dbgs() << "Height " << SU->getHeight() << ": ";
       SU->dump(DAG);
#else
   return Priority;
 #endif
 }
 
 //===----------------------------------------------------------------------===//
 //                     Register Pressure Tracking
 //===----------------------------------------------------------------------===//
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void RegReductionPQBase::dumpRegPressure() const {
   for (const TargetRegisterClass *RC : TRI->regclasses()) {
     unsigned Id = RC->getID();
     unsigned RP = RegPressure[Id];
     if (!RP) continue;
     DEBUG(dbgs() << TRI->getRegClassName(RC) << ": " << RP << " / "
           << RegLimit[Id] << '\n');
   }

llvm/trunk/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp

if (TargetRegisterInfo::isVirtualRegister(Reg))
       Latency = (Latency > 1) ? Latency - 1 : 1;
   }
   if (Latency >= 0)
     dep.setLatency(Latency);
 }
 
 void ScheduleDAGSDNodes::dumpNode(const SUnit *SU) const {
   // Cannot completely remove virtual function even in release mode.
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   if (!SU->getNode()) {
     dbgs() << "PHYS REG COPY\n";
     return;
   }
 
   SU->getNode()->dump(DAG);
   dbgs() << "\n";
   SmallVector<SDNode *, 4> GluedNodes;
   for (SDNode *N = SU->getNode()->getGluedNode(); N; N = N->getGluedNode())
     GluedNodes.push_back(N);
   while (!GluedNodes.empty()) {
     dbgs() << "    ";
     GluedNodes.back()->dump(DAG);
     dbgs() << "\n";
     GluedNodes.pop_back();
   }
 #endif
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 void ScheduleDAGSDNodes::dumpSchedule() const {
   for (unsigned i = 0, e = Sequence.size(); i != e; i++) {
     if (SUnit *SU = Sequence[i])
       SU->dump(this);
     else
       dbgs() << "**** NOOP ****\n";
   }
 }

llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp

 #ifndef NDEBUG
     OS << 't' << Node.PersistentId;
 #else
     OS << (const void*)&Node;
 #endif
   });
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void SDNode::dump() const { dump(nullptr); }
 
 LLVM_DUMP_METHOD void SDNode::dump(const SelectionDAG *G) const {
   print(dbgs(), G);
   dbgs() << '\n';
 }
 #endif
 

 /// Return true if this node is so simple that we should just print it inline
 /// if it appears as an operand.
 static bool shouldPrintInline(const SDNode &Node) {
   if (Node.getOpcode() == ISD::EntryToken)
     return false;
   return Node.getNumOperands() == 0;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 static void DumpNodes(const SDNode *N, unsigned indent, const SelectionDAG *G) {
   for (const SDValue &Op : N->op_values()) {
     if (shouldPrintInline(*Op.getNode()))
       continue;
     if (Op.getNode()->hasOneUse())
       DumpNodes(Op.getNode(), indent+2, G);
   }
 
static bool printOperand(raw_ostream &OS, const SelectionDAG *G,
   } else {
     OS << PrintNodeId(*Value.getNode());
     if (unsigned RN = Value.getResNo())
       OS << ':' << RN;
     return false;
   }
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 using VisitedSDNodeSet = SmallPtrSet<const SDNode *, 32>;
 
 static void DumpNodesr(raw_ostream &OS, const SDNode *N, unsigned indent,
                        const SelectionDAG *G, VisitedSDNodeSet &once) {
   if (!once.insert(N).second) // If we've been here before, return now.
     return;
 
   // Dump the current SDNode, but don't end the line yet.
void SDNode::printrWithDepth(raw_ostream &OS, const SelectionDAG *G,
   printrWithDepthHelper(OS, this, G, depth, 0);
 }
 
 void SDNode::printrFull(raw_ostream &OS, const SelectionDAG *G) const {
   // Don't print impossibly deep things.
   printrWithDepth(OS, G, 10);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD
 void SDNode::dumprWithDepth(const SelectionDAG *G, unsigned depth) const {
   printrWithDepth(dbgs(), G, depth);
 }
 
 LLVM_DUMP_METHOD void SDNode::dumprFull(const SelectionDAG *G) const {
   // Don't print impossibly deep things.
   dumprWithDepth(G, 10);

llvm/trunk/lib/CodeGen/SlotIndexes.cpp

void SlotIndexes::repairIndexesInRange(MachineBasicBlock *MBB,
   for (MachineBasicBlock::iterator I = End; I != Begin;) {
     --I;
     MachineInstr &MI = *I;
     if (!MI.isDebugValue() && mi2iMap.find(&MI) == mi2iMap.end())
       insertMachineInstrInMaps(MI);
   }
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void SlotIndexes::dump() const {
   for (IndexList::const_iterator itr = indexList.begin();
        itr != indexList.end(); ++itr) {
     dbgs() << itr->getIndex() << " ";
 
     if (itr->getInstr()) {
       dbgs() << *itr->getInstr();
     } else {

 // Print a SlotIndex to a raw_ostream.
 void SlotIndex::print(raw_ostream &os) const {
   if (isValid())
     os << listEntry()->getIndex() << "Berd"[getSlot()];
   else
     os << "invalid";
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 // Dump a SlotIndex to stderr.
 LLVM_DUMP_METHOD void SlotIndex::dump() const {
   print(dbgs());
   dbgs() << "\n";
 }
 #endif
 

llvm/trunk/lib/CodeGen/SplitKit.cpp

if (SpillMode)
     LRCalc[1].reset(&VRM.getMachineFunction(), LIS.getSlotIndexes(), &MDT,
                     &LIS.getVNInfoAllocator());
 
   // We don't need an AliasAnalysis since we will only be performing
   // cheap-as-a-copy remats anyway.
   Edit->anyRematerializable(nullptr);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void SplitEditor::dump() const {
   if (RegAssign.empty()) {
     dbgs() << " empty\n";
     return;
   }
 
   for (RegAssignMap::const_iterator I = RegAssign.begin(); I.valid(); ++I)
     dbgs() << " [" << I.start() << ';' << I.stop() << "):" << I.value();

llvm/trunk/lib/CodeGen/StackColoring.cpp

INITIALIZE_PASS_END(StackColoring, DEBUG_TYPE,
                     "Merge disjoint stack slots", false, false)
 
 void StackColoring::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<SlotIndexes>();
   AU.addRequired<StackProtector>();
   MachineFunctionPass::getAnalysisUsage(AU);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void StackColoring::dumpBV(const char *tag,
                                             const BitVector &BV) const {
   dbgs() << tag << " : { ";
   for (unsigned I = 0, E = BV.size(); I != E; ++I)
     dbgs() << BV.test(I) << " ";
   dbgs() << "}\n";
 }
 

llvm/trunk/lib/CodeGen/TargetRegisterInfo.cpp

bool TargetRegisterInfo::regmaskSubsetEqual(const uint32_t *mask0,
                                             const uint32_t *mask1) const {
   unsigned N = (getNumRegs()+31) / 32;
   for (unsigned I = 0; I < N; ++I)
     if ((mask0[I] & mask1[I]) != mask0[I])
       return false;
   return true;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD
 void TargetRegisterInfo::dumpReg(unsigned Reg, unsigned SubRegIndex,
                                  const TargetRegisterInfo *TRI) {
   dbgs() << PrintReg(Reg, TRI, SubRegIndex) << "\n";
 }
 #endif

llvm/trunk/lib/CodeGen/VirtRegMap.cpp

for (unsigned i = 0, e = MRI->getNumVirtRegs(); i != e; ++i) {
     if (Virt2StackSlotMap[Reg] != VirtRegMap::NO_STACK_SLOT) {
       OS << '[' << PrintReg(Reg, TRI) << " -> fi#" << Virt2StackSlotMap[Reg]
          << "] " << TRI->getRegClassName(MRI->getRegClass(Reg)) << "\n";
     }
   }
   OS << '\n';
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void VirtRegMap::dump() const {
   print(dbgs());
 }
 #endif
 
 //===----------------------------------------------------------------------===//
 //                              VirtRegRewriter
 //===----------------------------------------------------------------------===//

llvm/trunk/lib/IR/AsmWriter.cpp

void Metadata::print(raw_ostream &OS, const Module *M,
   printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
 }
 
 void Metadata::print(raw_ostream &OS, ModuleSlotTracker &MST,
                      const Module *M, bool /*IsForDebug*/) const {
   printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 // Value::dump - allow easy printing of Values from the debugger.
 LLVM_DUMP_METHOD
 void Value::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
 
 // Type::dump - allow easy printing of Types from the debugger.
 LLVM_DUMP_METHOD
 void Type::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
 

llvm/trunk/lib/IR/Attributes.cpp

 AttributeSet::iterator AttributeSet::begin() const {
   return SetNode ? SetNode->begin() : nullptr;
 }
 
 AttributeSet::iterator AttributeSet::end() const {
   return SetNode ? SetNode->end() : nullptr;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void AttributeSet::dump() const {
   dbgs() << "AS =\n";
     dbgs() << "  { ";
     dbgs() << getAsString(true) << " }\n";
 }
 #endif
 
 //===----------------------------------------------------------------------===//

 }
 
 void AttributeListImpl::Profile(FoldingSetNodeID &ID,
                                 ArrayRef<AttributeSet> Sets) {
   for (const auto &Set : Sets)
     ID.AddPointer(Set.SetNode);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void AttributeListImpl::dump() const {
   AttributeList(const_cast<AttributeListImpl *>(this)).dump();
 }
 #endif
 
 //===----------------------------------------------------------------------===//
 // AttributeList Construction and Mutation Methods
 //===----------------------------------------------------------------------===//

 //===----------------------------------------------------------------------===//
 // AttributeList Introspection Methods
 //===----------------------------------------------------------------------===//
 
 unsigned AttributeList::getNumAttrSets() const {
   return pImpl ? pImpl->NumAttrSets : 0;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void AttributeList::dump() const {
   dbgs() << "PAL[\n";
 
   for (unsigned i = index_begin(), e = index_end(); i != e; ++i) {
     if (getAttributes(i).hasAttributes())
       dbgs() << "  { " << i << " => " << getAsString(i) << " }\n";
   }
 

llvm/trunk/lib/IR/ConstantRange.cpp

void ConstantRange::print(raw_ostream &OS) const {
   if (isFullSet())
     OS << "full-set";
   else if (isEmptySet())
     OS << "empty-set";
   else
     OS << "[" << Lower << "," << Upper << ")";
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void ConstantRange::dump() const {
   print(dbgs());
 }
 #endif
 
 ConstantRange llvm::getConstantRangeFromMetadata(const MDNode &Ranges) {
   const unsigned NumRanges = Ranges.getNumOperands() / 2;
   assert(NumRanges >= 1 && "Must have at least one range!");

llvm/trunk/lib/IR/Core.cpp

 {
     return unwrap(Ty)->isSized();
 }
 
 LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty) {
   return wrap(&unwrap(Ty)->getContext());
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void LLVMDumpType(LLVMTypeRef Ty) {
   return unwrap(Ty)->dump();
 }
 #endif
 
 char *LLVMPrintTypeToString(LLVMTypeRef Ty) {
   std::string buf;
   raw_string_ostream os(buf);

llvm/trunk/lib/IR/DebugLoc.cpp

DebugLoc DebugLoc::appendInlinedAt(DebugLoc DL, DILocation *InlinedAt,
   // map of already-constructed inlined-at nodes.
   for (const DILocation *MD : reverse(InlinedAtLocations))
     Cache[MD] = Last = DILocation::getDistinct(
         Ctx, MD->getLine(), MD->getColumn(), MD->getScope(), Last);
 
   return Last;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void DebugLoc::dump() const {
   if (!Loc)
     return;
 
   dbgs() << getLine();
   if (getCol() != 0)
     dbgs() << ',' << getCol();
   if (DebugLoc InlinedAtDL = DebugLoc(getInlinedAt())) {

llvm/trunk/lib/IR/GCOV.cpp

bool GCOVFile::readGCDA(GCOVBuffer &Buffer) {
   return true;
 }
 
 void GCOVFile::print(raw_ostream &OS) const {
   for (const auto &FPtr : Functions)
     FPtr->print(OS);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 /// dump - Dump GCOVFile content to dbgs() for debugging purposes.
 LLVM_DUMP_METHOD void GCOVFile::dump() const {
   print(dbgs());
 }
 #endif
 
 /// collectLineCounts - Collect line counts. This must be used after
 /// reading .gcno and .gcda files.

 
 void GCOVFunction::print(raw_ostream &OS) const {
   OS << "===== " << Name << " (" << Ident << ") @ " << Filename << ":"
      << LineNumber << "\n";
   for (const auto &Block : Blocks)
     Block->print(OS);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 /// dump - Dump GCOVFunction content to dbgs() for debugging purposes.
 LLVM_DUMP_METHOD void GCOVFunction::dump() const {
   print(dbgs());
 }
 #endif
 
 /// collectLineCounts - Collect line counts. This must be used after
 /// reading .gcno and .gcda files.
void GCOVBlock::print(raw_ostream &OS) const {
   if (!Lines.empty()) {
     OS << "\tLines : ";
     for (uint32_t N : Lines)
       OS << (N) << ",";
     OS << "\n";
   }
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 /// dump - Dump GCOVBlock content to dbgs() for debugging purposes.
 LLVM_DUMP_METHOD void GCOVBlock::dump() const {
   print(dbgs());
 }
 #endif
 
 //===----------------------------------------------------------------------===//
 // FileInfo implementation.

llvm/trunk/lib/IR/Pass.cpp

 
 // print - Print out the internal state of the pass.  This is called by Analyze
 // to print out the contents of an analysis.  Otherwise it is not necessary to
 // implement this method.
 void Pass::print(raw_ostream &OS, const Module *) const {
   OS << "Pass::print not implemented for pass: '" << getPassName() << "'!\n";
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 // dump - call print(cerr);
 LLVM_DUMP_METHOD void Pass::dump() const {
   print(dbgs(), nullptr);
 }
 #endif
 
 //===----------------------------------------------------------------------===//
 // ImmutablePass Implementation

llvm/trunk/lib/IR/ValueSymbolTable.cpp

if (IterBool.second) {
     return &*IterBool.first;
   }
   
   // Otherwise, there is a naming conflict.  Rename this value.
   SmallString<256> UniqueName(Name.begin(), Name.end());
   return makeUniqueName(V, UniqueName);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 // dump - print out the symbol table
 //
 LLVM_DUMP_METHOD void ValueSymbolTable::dump() const {
   //dbgs() << "ValueSymbolTable:\n";
   for (const auto &I : *this) {
     //dbgs() << "  '" << I->getKeyData() << "' = ";
     I.getValue()->dump();
     //dbgs() << "\n";
   }
 }
 #endif

llvm/trunk/lib/MC/MCExpr.cpp

case MCExpr::Binary: {
     }
     return;
   }
   }
 
   llvm_unreachable("Invalid expression kind!");
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MCExpr::dump() const {
   dbgs() << *this;
   dbgs() << '\n';
 }
 #endif
 
 /* *** */
 

llvm/trunk/lib/MC/MCFragment.cpp

raw_ostream &operator<<(raw_ostream &OS, const MCFixup &AF) {
   OS << "<MCFixup" << " Offset:" << AF.getOffset()
      << " Value:" << *AF.getValue()
      << " Kind:" << AF.getKind() << ">";
   return OS;
 }
 
 } // end namespace llvm
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MCFragment::dump() const {
   raw_ostream &OS = errs();
 
   OS << "<";
   switch (getKind()) {
   case MCFragment::FT_Align: OS << "MCAlignFragment"; break;
   case MCFragment::FT_Data:  OS << "MCDataFragment"; break;
   case MCFragment::FT_CompactEncodedInst:

llvm/trunk/lib/MC/MCInst.cpp

else if (isExpr()) {
     OS << "Expr:(" << *getExpr() << ")";
   } else if (isInst()) {
     OS << "Inst:(" << *getInst() << ")";
   } else
     OS << "UNDEFINED";
   OS << ">";
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MCOperand::dump() const {
   print(dbgs());
   dbgs() << "\n";
 }
 #endif
 
 void MCInst::print(raw_ostream &OS) const {
   OS << "<MCInst " << getOpcode();
void MCInst::dump_pretty(raw_ostream &OS, const MCInstPrinter *Printer,
 
   for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
     OS << Separator;
     getOperand(i).print(OS);
   }
   OS << ">";
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MCInst::dump() const {
   print(dbgs());
   dbgs() << "\n";
 }
 #endif

llvm/trunk/lib/MC/MCLabel.cpp

 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 void MCLabel::print(raw_ostream &OS) const {
   OS << '"' << getInstance() << '"';
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MCLabel::dump() const {
   print(dbgs());
 }
 #endif

llvm/trunk/lib/MC/MCParser/MCAsmParser.cpp

 
 bool MCAsmParser::parseExpression(const MCExpr *&Res) {
   SMLoc L;
   return parseExpression(Res, L);
 }
 
 void MCParsedAsmOperand::dump() const {
   // Cannot completely remove virtual function even in release mode.
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   dbgs() << "  " << *this;
 #endif
 }

llvm/trunk/lib/MC/MCSection.cpp

if (!ExactMatch && Subsection != 0) {
     SubsectionFragmentMap.insert(MI, std::make_pair(Subsection, F));
     getFragmentList().insert(IP, F);
     F->setParent(this);
   }
 
   return IP;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MCSection::dump() const {
   raw_ostream &OS = errs();
 
   OS << "<MCSection";
   OS << " Fragments:[\n      ";
   for (auto it = begin(), ie = end(); it != ie; ++it) {
     if (it != begin())
       OS << ",\n      ";
     it->dump();
   }
   OS << "]>";
 }
 #endif

llvm/trunk/lib/MC/MCSymbol.cpp

for (char C : Name) {
     else if (C == '"')
       OS << "\\\"";
     else
       OS << C;
   }
   OS << '"';
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MCSymbol::dump() const {
   dbgs() << *this;
 }
 #endif

llvm/trunk/lib/MC/MCValue.cpp

if (getSymB()) {
     OS << " - ";
     OS << *getSymB();
   }
 
   if (getConstant())
     OS << " + " << getConstant();
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MCValue::dump() const {
   print(dbgs());
 }
 #endif
 
 MCSymbolRefExpr::VariantKind MCValue::getAccessVariant() const {
   const MCSymbolRefExpr *B = getSymB();
   if (B) {

llvm/trunk/lib/MC/SubtargetFeature.cpp

 }
 
 void SubtargetFeatures::print(raw_ostream &OS) const {
   for (auto &F : Features)
     OS << F << " ";
   OS << "\n";
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void SubtargetFeatures::dump() const {
   print(dbgs());
 }
 #endif
 
 void SubtargetFeatures::getDefaultSubtargetFeatures(const Triple& Triple) {
   // FIXME: This is an inelegant way of specifying the features of a
   // subtarget. It would be better if we could encode this information

llvm/trunk/lib/MC/WasmObjectWriter.cpp

struct WasmRelocationEntry {
   }
 
   void print(raw_ostream &Out) const {
     Out << "Off=" << Offset << ", Sym=" << *Symbol << ", Addend=" << Addend
         << ", Type=" << Type
         << ", FixupSection=" << FixupSection->getSectionName();
   }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
 #endif
 };
 
 #if !defined(NDEBUG)
 raw_ostream &operator<<(raw_ostream &OS, const WasmRelocationEntry &Rel) {
   Rel.print(OS);
   return OS;

llvm/trunk/lib/Option/Arg.cpp

void Arg::print(raw_ostream& O) const {
   for (unsigned i = 0, e = Values.size(); i != e; ++i) {
     if (i) O << ", ";
     O << "'" << Values[i] << "'";
   }
 
   O << "]>\n";
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void Arg::dump() const { print(dbgs()); }
 #endif
 
 std::string Arg::getAsString(const ArgList &Args) const {
   SmallString<256> Res;
   raw_svector_ostream OS(Res);
 
   ArgStringList ASL;

llvm/trunk/lib/Option/ArgList.cpp

 
 void ArgList::print(raw_ostream &O) const {
   for (Arg *A : *this) {
     O << "* ";
     A->print(O);
   }
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void ArgList::dump() const { print(dbgs()); }
 #endif
 
 void InputArgList::releaseMemory() {
   // An InputArgList always owns its arguments.
   for (Arg *A : *this)
     delete A;
 }

llvm/trunk/lib/Option/Option.cpp

#undef P
   }
 
   if (getKind() == MultiArgClass)
     O << " NumArgs:" << getNumArgs();
 
   O << ">\n";
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void Option::dump() const { print(dbgs()); }
 #endif
 
 bool Option::matches(OptSpecifier Opt) const {
   // Aliases are never considered in matching, look through them.
   const Option Alias = getAlias();
   if (Alias.isValid())
     return Alias.matches(Opt);

llvm/trunk/lib/ProfileData/SampleProf.cpp

 }
 
 raw_ostream &llvm::sampleprof::operator<<(raw_ostream &OS,
                                           const LineLocation &Loc) {
   Loc.print(OS);
   return OS;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void LineLocation::dump() const { print(dbgs()); }
 #endif
 
 /// \brief Print the sample record to the stream \p OS indented by \p Indent.
 void SampleRecord::print(raw_ostream &OS, unsigned Indent) const {
   OS << NumSamples;
   if (hasCalls()) {
     OS << ", calls:";
     for (const auto &I : getCallTargets())
       OS << " " << I.first() << ":" << I.second;
   }
   OS << "\n";
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void SampleRecord::dump() const { print(dbgs(), 0); }
 #endif
 
 raw_ostream &llvm::sampleprof::operator<<(raw_ostream &OS,
                                           const SampleRecord &Sample) {
   Sample.print(OS, 0);
   return OS;
 }

 }
 
 raw_ostream &llvm::sampleprof::operator<<(raw_ostream &OS,
                                           const FunctionSamples &FS) {
   FS.print(OS);
   return OS;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void FunctionSamples::dump() const { print(dbgs(), 0); }
 #endif

llvm/trunk/lib/Support/APFloat.cpp

 }
 
 void APFloat::print(raw_ostream &OS) const {
   SmallVector<char, 16> Buffer;
   toString(Buffer);
   OS << Buffer << "\n";
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void APFloat::dump() const { print(dbgs()); }
 #endif
 
 void APFloat::Profile(FoldingSetNodeID &NID) const {
   NID.Add(bitcastToAPInt());
 }
 
 /* Same as convertToInteger(integerPart*, ...), except the result is returned in

llvm/trunk/lib/Support/APInt.cpp

 /// Returns the APInt as a std::string. Note that this is an inefficient method.
 /// It is better to pass in a SmallVector/SmallString to the methods above.
 std::string APInt::toString(unsigned Radix = 10, bool Signed = true) const {
   SmallString<40> S;
   toString(S, Radix, Signed, /* formatAsCLiteral = */false);
   return S.str();
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void APInt::dump() const {
   SmallString<40> S, U;
   this->toStringUnsigned(U);
   this->toStringSigned(S);
   dbgs() << "APInt(" << BitWidth << "b, "
          << U << "u " << S << "s)\n";
 }
 #endif

llvm/trunk/lib/Support/BranchProbability.cpp

raw_ostream &BranchProbability::print(raw_ostream &OS) const {
 
   // Get a percentage rounded to two decimal digits. This avoids
   // implementation-defined rounding inside printf.
   double Percent = rint(((double)N / D) * 100.0 * 100.0) / 100.0;
   return OS << format("0x%08" PRIx32 " / 0x%08" PRIx32 " = %.2f%%", N, D,
                       Percent);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void BranchProbability::dump() const { print(dbgs()) << '\n'; }
 #endif
 
 BranchProbability::BranchProbability(uint32_t Numerator, uint32_t Denominator) {
   assert(Denominator > 0 && "Denominator cannot be 0!");
   assert(Numerator <= Denominator && "Probability cannot be bigger than 1!");
   if (Denominator == D)
     N = Numerator;

llvm/trunk/lib/Support/Twine.cpp

 void Twine::printRepr(raw_ostream &OS) const {
   OS << "(Twine ";
   printOneChildRepr(OS, LHS, getLHSKind());
   OS << " ";
   printOneChildRepr(OS, RHS, getRHSKind());
   OS << ")";
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void Twine::dump() const {
   print(dbgs());
 }
 
 LLVM_DUMP_METHOD void Twine::dumpRepr() const {
   printRepr(dbgs());
 }
 #endif

llvm/trunk/lib/TableGen/Record.cpp

 //===----------------------------------------------------------------------===//
 
 BitRecTy BitRecTy::Shared;
 CodeRecTy CodeRecTy::Shared;
 IntRecTy IntRecTy::Shared;
 StringRecTy StringRecTy::Shared;
 DagRecTy DagRecTy::Shared;
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void RecTy::dump() const { print(errs()); }
 #endif
 
 ListRecTy *RecTy::getListTy() {
   if (!ListTy)
     ListTy = new(Allocator) ListRecTy(this);
   return ListTy;
 }

 }
 
 //===----------------------------------------------------------------------===//
 //    Initializer implementations
 //===----------------------------------------------------------------------===//
 
 void Init::anchor() {}
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void Init::dump() const { return print(errs()); }
 #endif
 
 UnsetInit *UnsetInit::get() {
   static UnsetInit TheInit;
   return &TheInit;
 }
 
RecordVal::RecordVal(Init *N, RecTy *T, bool P)
   Value = UnsetInit::get()->convertInitializerTo(T);
   assert(Value && "Cannot create unset value for current type!");
 }
 
 StringRef RecordVal::getName() const {
   return cast<StringInit>(getNameInit())->getValue();
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void RecordVal::dump() const { errs() << *this; }
 #endif
 
 void RecordVal::print(raw_ostream &OS, bool PrintSem) const {
   if (getPrefix()) OS << "field ";
   OS << *getType() << " " << getNameInitAsString();
 
   if (getValue())
void Record::resolveReferencesTo(const RecordVal *RV) {
   Init *OldName = getNameInit();
   Init *NewName = Name->resolveReferences(*this, RV);
   if (NewName != OldName) {
     // Re-register with RecordKeeper.
     setName(NewName);
   }
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void Record::dump() const { errs() << *this; }
 #endif
 
 raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) {
   OS << R.getNameInitAsString();
 
   ArrayRef<Init *> TArgs = R.getTemplateArgs();
   if (!TArgs.empty()) {
PrintFatalError(getLoc(), "Record `" + getName() +
       "' does not have a field named `" + FieldName + "'!\n");
 
   if (DagInit *DI = dyn_cast<DagInit>(R->getValue()))
     return DI;
   PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
     FieldName + "' does not have a dag initializer!");
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MultiClass::dump() const {
   errs() << "Record:\n";
   Rec.dump();
 
   errs() << "Defs:\n";
   for (const auto &Proto : DefPrototypes)
     Proto->dump();
 }

llvm/trunk/lib/TableGen/TGParser.cpp

struct SubMultiClassReference {
   SmallVector<Init*, 4> TemplateArgs;
 
   SubMultiClassReference() : MC(nullptr) {}
 
   bool isInvalid() const { return MC == nullptr; }
   void dump() const;
 };
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void SubMultiClassReference::dump() const {
   errs() << "Multiclass:\n";
 
   MC->dump();
 
   errs() << "Template args:\n";
   for (Init *TA : TemplateArgs)
     TA->dump();

llvm/trunk/lib/Target/AMDGPU/AMDGPUMachineCFGStructurizer.cpp

bool PHILinearize::isSource(unsigned Reg, MachineBasicBlock *SourceMBB) {
   unsigned DestReg;
   return findDest(Reg, SourceMBB, DestReg);
 }
 
 unsigned PHILinearize::getNumSources(unsigned DestReg) {
   return phiInfoElementGetSources(findPHIInfoElement(DestReg)).size();
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void PHILinearize::dump(MachineRegisterInfo *MRI) {
   const TargetRegisterInfo *TRI = MRI->getTargetRegisterInfo();
   dbgs() << "=PHIInfo Start=\n";
   for (auto PII : this->PHIInfo) {
     PHIInfoElementT &Element = *PII;
     dbgs() << "Dest: " << PrintReg(Element.DestReg, TRI)
            << " Sources: {";
     for (auto &SI : Element.Sources) {

llvm/trunk/lib/Target/AMDGPU/GCNIterativeScheduler.cpp

 }
 static inline MachineInstr *getMachineInstr(const SUnit *SU) {
   return SU->getInstr();
 }
 static inline MachineInstr *getMachineInstr(const SUnit &SU) {
   return SU.getInstr();
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD
 static void printRegion(raw_ostream &OS,
                         MachineBasicBlock::iterator Begin,
                         MachineBasicBlock::iterator End,
                         const LiveIntervals *LIS,
                         unsigned MaxInstNum =
                           std::numeric_limits<unsigned>::max()) {
   auto BB = Begin->getParent();

llvm/trunk/lib/Target/AMDGPU/GCNRegPressure.cpp

 #include "llvm/Target/TargetRegisterInfo.h"
 #include <algorithm>
 #include <cassert>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "machine-scheduler"
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD
 void llvm::printLivesAt(SlotIndex SI,
                         const LiveIntervals &LIS,
                         const MachineRegisterInfo &MRI) {
   dbgs() << "Live regs at " << SI << ": "
          << *LIS.getInstructionFromIndex(SI);
   unsigned Num = 0;
   for (unsigned I = 0, E = MRI.getNumVirtRegs(); I != E; ++I) {
if (SGPRFirst) {
       if (VW != OtherVW)
         return VW < OtherVW;
     }
   }
   return SGPRImportant ? (getSGPRNum() < O.getSGPRNum()):
                          (getVGPRNum() < O.getVGPRNum());
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD
 void GCNRegPressure::print(raw_ostream &OS, const SISubtarget *ST) const {
   OS << "VGPRs: " << getVGPRNum();
   if (ST) OS << "(O" << ST->getOccupancyWithNumVGPRs(getVGPRNum()) << ')';
   OS << ", SGPRs: " << getSGPRNum();
   if (ST) OS << "(O" << ST->getOccupancyWithNumSGPRs(getSGPRNum()) << ')';
   OS << ", LVGPR WT: " << getVGPRTuplesWeight()
      << ", LSGPR WT: " << getSGPRTuplesWeight();

 
 bool GCNDownwardRPTracker::advance(MachineBasicBlock::const_iterator Begin,
                                    MachineBasicBlock::const_iterator End,
                                    const LiveRegSet *LiveRegsCopy) {
   reset(*Begin, LiveRegsCopy);
   return advance(End);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD
 static void reportMismatch(const GCNRPTracker::LiveRegSet &LISLR,
                            const GCNRPTracker::LiveRegSet &TrackedLR,
                            const TargetRegisterInfo *TRI) {
   for (auto const &P : TrackedLR) {
     auto I = LISLR.find(P.first);
     if (I == LISLR.end()) {
       dbgs() << "  " << PrintReg(P.first, TRI)

llvm/trunk/lib/Target/ARM/ARMConstantIslandPass.cpp

for (unsigned i = 0, e = CPUsers.size(); i != e; ++i) {
     DEBUG(dbgs() << "Out of range.\n");
     dumpBBs();
     DEBUG(MF->dump());
     llvm_unreachable("Constant pool entry out of range!");
   }
 #endif
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 /// print block size and offset information - debugging
 LLVM_DUMP_METHOD void ARMConstantIslands::dumpBBs() {
   DEBUG({
     for (unsigned J = 0, E = BBInfo.size(); J !=E; ++J) {
       const BasicBlockInfo &BBI = BBInfo[J];
       dbgs() << format("%08x BB#%u\t", BBI.Offset, J)
              << " kb=" << unsigned(BBI.KnownBits)
              << " ua=" << unsigned(BBI.Unalign)

llvm/trunk/lib/Target/ARM/ARMConstantPoolValue.cpp

if (ACPV->Kind == Kind &&
     // Two PC relative constpool entries containing the same GV address or
     // external symbols. FIXME: What about blockaddress?
     if (Kind == ARMCP::CPValue || Kind == ARMCP::CPExtSymbol)
       return true;
   }
   return false;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void ARMConstantPoolValue::dump() const {
   errs() << "  " << *this;
 }
 #endif
 
 void ARMConstantPoolValue::print(raw_ostream &O) const {
   if (Modifier) O << "(" << getModifierText() << ")";
   if (PCAdjust != 0) {

llvm/trunk/lib/Target/Hexagon/HexagonSplitDouble.cpp

 char HexagonSplitDoubleRegs::ID;
 int HexagonSplitDoubleRegs::Counter = 0;
 const TargetRegisterClass *const HexagonSplitDoubleRegs::DoubleRC =
     &Hexagon::DoubleRegsRegClass;
 
 INITIALIZE_PASS(HexagonSplitDoubleRegs, "hexagon-split-double",
   "Hexagon Split Double Registers", false, false)
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void HexagonSplitDoubleRegs::dump_partition(raw_ostream &os,
       const USet &Part, const TargetRegisterInfo &TRI) {
   dbgs() << '{';
   for (auto I : Part)
     dbgs() << ' ' << PrintReg(I, &TRI);
   dbgs() << " }";
 }
 #endif

llvm/trunk/lib/Target/MSP430/MSP430ISelDAGToDAG.cpp

MSP430ISelAddressMode()
       : BaseType(RegBase), Disp(0), GV(nullptr), CP(nullptr),
         BlockAddr(nullptr), ES(nullptr), JT(-1), Align(0) {
     }
 
     bool hasSymbolicDisplacement() const {
       return GV != nullptr || CP != nullptr || ES != nullptr || JT != -1;
     }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
     LLVM_DUMP_METHOD void dump() {
       errs() << "MSP430ISelAddressMode " << this << '\n';
       if (BaseType == RegBase && Base.Reg.getNode() != nullptr) {
         errs() << "Base.Reg ";
         Base.Reg.getNode()->dump();
       } else if (BaseType == FrameIndexBase) {
         errs() << " Base.FrameIndex " << Base.FrameIndex << '\n';
       }

llvm/trunk/lib/Target/Mips/MipsConstantIslandPass.cpp

 
 bool MipsConstantIslands::isOffsetInRange
   (unsigned UserOffset, unsigned TrialOffset,
    const CPUser &U) {
   return isOffsetInRange(UserOffset, TrialOffset,
                          U.getMaxDisp(), U.NegOk);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 /// print block size and offset information - debugging
 LLVM_DUMP_METHOD void MipsConstantIslands::dumpBBs() {
   for (unsigned J = 0, E = BBInfo.size(); J !=E; ++J) {
     const BasicBlockInfo &BBI = BBInfo[J];
     dbgs() << format("%08x BB#%u\t", BBI.Offset, J)
            << format(" size=%#x\n", BBInfo[J].Size);
   }
 }

llvm/trunk/lib/Target/PowerPC/PPCVSXSwapRemoval.cpp

if (SwapVector[EntryIdx].WillRemove) {
 
       MI->eraseFromParent();
     }
   }
 
   return Changed;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 // For debug purposes, dump the contents of the swap vector.
 LLVM_DUMP_METHOD void PPCVSXSwapRemoval::dumpSwapVector() {
 
   for (unsigned EntryIdx = 0; EntryIdx < SwapVector.size(); ++EntryIdx) {
 
     MachineInstr *MI = SwapVector[EntryIdx].VSEMI;
     int ID = SwapVector[EntryIdx].VSEId;
 

llvm/trunk/lib/Target/X86/X86FloatingPoint.cpp

private:
     unsigned RegMap[NumFPRegs];
 
     // Set up our stack model to match the incoming registers to MBB.
     void setupBlockStack();
 
     // Shuffle live registers to match the expectations of successor blocks.
     void finishBlockStack();
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
     void dumpStack() const {
       dbgs() << "Stack contents:";
       for (unsigned i = 0; i != StackTop; ++i) {
         dbgs() << " FP" << Stack[i];
         assert(RegMap[Stack[i]] == i && "Stack[] doesn't match RegMap[]!");
       }
     }
 #endif

llvm/trunk/lib/Target/X86/X86ISelDAGToDAG.cpp

bool isRIPRelative() const {
       return false;
     }
 
     void setBaseReg(SDValue Reg) {
       BaseType = RegBase;
       Base_Reg = Reg;
     }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
     void dump() {
       dbgs() << "X86ISelAddressMode " << this << '\n';
       dbgs() << "Base_Reg ";
       if (Base_Reg.getNode())
         Base_Reg.getNode()->dump();
       else
         dbgs() << "nul";
       dbgs() << " Base.FrameIndex " << Base_FrameIndex << '\n'

llvm/trunk/lib/Transforms/Coroutines/CoroFrame.cpp

struct SuspendCrossingInfo {
   }
 
   bool isDefinitionAcrossSuspend(Instruction &I, User *U) const {
     return isDefinitionAcrossSuspend(I.getParent(), U);
   }
 };
 } // end anonymous namespace
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void SuspendCrossingInfo::dump(StringRef Label,
                                                 BitVector const &BV) const {
   dbgs() << Label << ":";
   for (size_t I = 0, N = BV.size(); I < N; ++I)
     if (BV[I])
       dbgs() << " " << Mapping.indexToBlock(I)->getName();
   dbgs() << "\n";
 }

llvm/trunk/lib/Transforms/Scalar/GVN.cpp

if (!Changed)
     return PreservedAnalyses::all();
   PreservedAnalyses PA;
   PA.preserve<DominatorTreeAnalysis>();
   PA.preserve<GlobalsAA>();
   PA.preserve<TargetLibraryAnalysis>();
   return PA;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void GVN::dump(DenseMap<uint32_t, Value*>& d) const {
   errs() << "{\n";
   for (DenseMap<uint32_t, Value*>::iterator I = d.begin(),
        E = d.end(); I != E; ++I) {
       errs() << I->first << "\n";
       I->second->dump();
   }
   errs() << "}\n";

llvm/trunk/lib/Transforms/Scalar/LoopStrengthReduce.cpp

public:
   SmallBitVector UsedByIndices;
 
   void print(raw_ostream &OS) const;
   void dump() const;
 };
 
 } // end anonymous namespace
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 void RegSortData::print(raw_ostream &OS) const {
   OS << "[NumUses=" << UsedByIndices.count() << ']';
 }
 
 LLVM_DUMP_METHOD void RegSortData::dump() const {
   print(errs()); errs() << '\n';
 }
 #endif
if (ScaledReg)
     if (RegUses.isRegUsedByUsesOtherThan(ScaledReg, LUIdx))
       return true;
   for (const SCEV *BaseReg : BaseRegs)
     if (RegUses.isRegUsedByUsesOtherThan(BaseReg, LUIdx))
       return true;
   return false;
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 void Formula::print(raw_ostream &OS) const {
   bool First = true;
   if (BaseGV) {
     if (!First) OS << " + "; else First = false;
     BaseGV->printAsOperand(OS, /*PrintType=*/false);
   }
   if (BaseOffset != 0) {
     if (!First) OS << " + "; else First = false;

 /// Choose the lower cost.
 bool Cost::isLess(Cost &Other, const TargetTransformInfo &TTI) {
   if (InsnsCost.getNumOccurrences() > 0 && InsnsCost &&
       C.Insns != Other.C.Insns)
     return C.Insns < Other.C.Insns;
   return TTI.isLSRCostLess(C, Other.C);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 void Cost::print(raw_ostream &OS) const {
   if (InsnsCost)
     OS << C.Insns << " instruction" << (C.Insns == 1 ? " " : "s ");
   OS << C.NumRegs << " reg" << (C.NumRegs == 1 ? "" : "s");
   if (C.AddRecCost != 0)
     OS << ", with addrec cost " << C.AddRecCost;
   if (C.NumIVMuls != 0)
     OS << ", plus " << C.NumIVMuls << " IV mul"
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
           L->contains(PN->getIncomingBlock(i)))
         return false;
     return true;
   }
 
   return !L->contains(UserInst);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 void LSRFixup::print(raw_ostream &OS) const {
   OS << "UserInst=";
   // Store is common and interesting enough to be worth special-casing.
   if (StoreInst *Store = dyn_cast<StoreInst>(UserInst)) {
     OS << "store ";
     Store->getOperand(0)->printAsOperand(OS, /*PrintType=*/false);
   } else if (UserInst->getType()->isVoidTy())
     OS << UserInst->getOpcodeName();
void LSRUse::RecomputeRegs(size_t LUIdx, RegUseTracker &RegUses) {
   }
 
   // Update the RegTracker.
   for (const SCEV *S : OldRegs)
     if (!Regs.count(S))
       RegUses.dropRegister(S, LUIdx);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 void LSRUse::print(raw_ostream &OS) const {
   OS << "LSR Use: Kind=";
   switch (Kind) {
   case Basic:    OS << "Basic"; break;
   case Special:  OS << "Special"; break;
   case ICmpZero: OS << "ICmpZero"; break;
   case Address:
     OS << "Address of ";
WorkItem(size_t LI, int64_t I, const SCEV *R)
     : LUIdx(LI), Imm(I), OrigReg(R) {}
 
   void print(raw_ostream &OS) const;
   void dump() const;
 };
 
 } // end anonymous namespace
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 void WorkItem::print(raw_ostream &OS) const {
   OS << "in formulae referencing " << *OrigReg << " in use " << LUIdx
      << " , add offset " << Imm;
 }
 
 LLVM_DUMP_METHOD void WorkItem::dump() const {
   print(errs()); errs() << '\n';
 }
for (const Formula &F : LU.Formulae)
                         F) && "Illegal formula generated!");
   };
 #endif
 
   // Now that we've decided what we want, make it so.
   ImplementSolution(Solution);
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 void LSRInstance::print_factors_and_types(raw_ostream &OS) const {
   if (Factors.empty() && Types.empty()) return;
 
   OS << "LSR has identified the following interesting factors and types: ";
   bool First = true;
 
   for (int64_t Factor : Factors) {
     if (!First) OS << ", ";

llvm/trunk/lib/Transforms/Scalar/SROA.cpp

public:
   /// \brief Access the dead operands referring to this alloca.
   ///
   /// These are operands which have cannot actually be used to refer to the
   /// alloca as they are outside its range and the user doesn't correct for
   /// that. These mostly consist of PHI node inputs and the like which we just
   /// need to replace with undef.
   ArrayRef<Use *> getDeadOperands() const { return DeadOperands; }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   void print(raw_ostream &OS, const_iterator I, StringRef Indent = "  ") const;
   void printSlice(raw_ostream &OS, const_iterator I,
                   StringRef Indent = "  ") const;
   void printUse(raw_ostream &OS, const_iterator I,
                 StringRef Indent = "  ") const;
   void print(raw_ostream &OS) const;
   void dump(const_iterator I) const;
   void dump() const;
 #endif
 
 private:
   template <typename DerivedT, typename RetT = void> class BuilderBase;
   class SliceBuilder;
 
   friend class AllocaSlices::SliceBuilder;
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
   /// \brief Handle to alloca instruction to simplify method interfaces.
   AllocaInst &AI;
 #endif
 
   /// \brief The instruction responsible for this alloca not having a known set
   /// of slices.
   ///
   /// When an instruction (potentially) escapes the pointer to the alloca, we
private:
   void visitSelectInst(SelectInst &SI) { visitPHINodeOrSelectInst(SI); }
 
   /// \brief Disable SROA entirely if there are unhandled users of the alloca.
   void visitInstruction(Instruction &I) { PI.setAborted(&I); }
 };
 
 AllocaSlices::AllocaSlices(const DataLayout &DL, AllocaInst &AI)
     :
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
       AI(AI),
 #endif
       PointerEscapingInstr(nullptr) {
   SliceBuilder PB(DL, AI, *this);
   SliceBuilder::PtrInfo PtrI = PB.visitPtr(AI);
   if (PtrI.isEscaped() || PtrI.isAborted()) {
     // FIXME: We should sink the escape vs. abort info into the caller nicely,
     // possibly by just storing the PtrInfo in the AllocaSlices.
#ifndef NDEBUG
   }
 #endif
 
   // Sort the uses. This arranges for the offsets to be in ascending order,
   // and the sizes to be in descending order.
   std::sort(Slices.begin(), Slices.end());
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 
 void AllocaSlices::print(raw_ostream &OS, const_iterator I,
                          StringRef Indent) const {
   printSlice(OS, I, Indent);
   OS << "\n";
   printUse(OS, I, Indent);
 }
 
for (const_iterator I = begin(), E = end(); I != E; ++I)
     print(OS, I);
 }
 
 LLVM_DUMP_METHOD void AllocaSlices::dump(const_iterator I) const {
   print(dbgs(), I);
 }
 LLVM_DUMP_METHOD void AllocaSlices::dump() const { print(dbgs()); }
 
-#endif // !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#endif // LLVM_ENABLE_DUMP
 
 /// Walk the range of a partitioning looking for a common type to cover this
 /// sequence of slices.
 static Type *findCommonType(AllocaSlices::const_iterator B,
                             AllocaSlices::const_iterator E,
                             uint64_t EndOffset) {
   Type *Ty = nullptr;
   bool TyIsCommon = true;

llvm/trunk/utils/TableGen/AsmMatcherEmitter.cpp

bool hasOptionalOperands() const {
     return find_if(Classes, [](const ClassInfo &Class) {
              return Class.IsOptional;
            }) != Classes.end();
   }
 };
 
 } // end anonymous namespace
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void MatchableInfo::dump() const {
   errs() << TheDef->getName() << " -- " << "flattened:\"" << AsmString <<"\"\n";
 
   for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i) {
     const AsmOperand &Op = AsmOperands[i];
     errs() << "  op[" << i << "] = " << Op.Class->ClassName << " - ";
     errs() << '\"' << Op.Token << "\"\n";
   }

llvm/trunk/utils/TableGen/SubtargetEmitter.cpp

 
 //
 // EmitSchedModel - Emits all scheduling model tables, folding common patterns.
 //
 void SubtargetEmitter::EmitSchedModel(raw_ostream &OS) {
   OS << "#ifdef DBGFIELD\n"
      << "#error \"<target>GenSubtargetInfo.inc requires a DBGFIELD macro\"\n"
      << "#endif\n"
-     << "#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)\n"
+     << "#ifdef LLVM_ENABLE_DUMP\n"
      << "#define DBGFIELD(x) x,\n"
      << "#else\n"
      << "#define DBGFIELD(x)\n"
      << "#endif\n";
 
   if (SchedModels.hasItineraries()) {
     std::vector<std::vector<InstrItinerary>> ProcItinLists;
     // Emit the stage data

llvm/trunk/utils/TableGen/SubtargetFeatureInfo.cpp

 
 #include "Types.h"
 #include "llvm/TableGen/Record.h"
 
 #include <map>
 
 using namespace llvm;
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#ifdef LLVM_ENABLE_DUMP
 LLVM_DUMP_METHOD void SubtargetFeatureInfo::dump() const {
   errs() << getEnumName() << " " << Index << "\n" << *TheDef;
 }
 #endif
 
 std::vector<std::pair<Record *, SubtargetFeatureInfo>>
 SubtargetFeatureInfo::getAll(const RecordKeeper &Records) {
   std::vector<std::pair<Record *, SubtargetFeatureInfo>> SubtargetFeatures;