Disable passes on optnone functions

[probinson]

Summary

Functions marked 'optnone' should not be optimized. Per Chandler's request, we avoided adding new attributes that Pass Manager would have to be aware of, and had each pass individually ignore 'optnone' functions.

[probinson]

Ping * 5. Hello? Phab review all refreshed and everything.
cc llvm-commits from phab, instead of pinging the original email thread, hopefully this will work.

[silvas]

Is there an email thread that decided on this direction? (so that I can catch up) It seems really odd (and difficult to maintain) to litter the codebase with checks in each pass.

In particular, what ever happened to just splitting all the notionally "optnone" functions into a separate module, and linking them back in at the end? That seems much more general. I don't see a response to http://article.gmane.org/gmane.comp.compilers.llvm.cvs/160085 or a response to Nick's original suggestion (which was restricted to using the commandline tools). It seems very simple to split the module like that.

[probinson]

-----Original Message-----
From: Sean Silva [mailto:[e-mail]]
Sent: Tuesday, January 14, 2014 6:57 PM
To: [e-mail]; Robinson, Paul
Cc: [e-mail]; [e-mail]
Subject: Re: [PATCH] Disable passes on optnone functions

Is there an email thread that decided on this direction? (so that I

can catch up) It seems really odd (and difficult to maintain) to litter
the codebase with checks in each pass.

There was this one, which has lots of other stuff on it and one comment
from Chandler not liking a less intrusive patch that added a flag and
caused the pass manager to make the decision instead of the individual
passes:
http://lists.cs.uiuc.edu/pipermail/llvm-commits/Week-of-Mon-20131111/194876.html

The implied model now is that every pass needs to be aware of the
attributes that would affect its operation, and Do The Right Thing(tm).
I'm not happy that it touches every transform pass either, but this is
specifically responding to Chandler's review comments. It doesn't
expand the PassManager<->Pass interface, at the cost of widening the
IR<->Pass interface.

In particular, what ever happened to just splitting all the notionally

"optnone" functions into a separate module, and linking them back in at
the end? That seems much more general. I don't see a response to
http://article.gmane.org/gmane.comp.compilers.llvm.cvs/160085 or a
response to Nick's original suggestion (which was restricted to using
the commandline tools). It seems very simple to split the module like
that.

Except it totally fails for LTO. I mentioned this to Nick at the
LLVM conference, which he accepted as a valid objection; sorry that
never got documented on the list.
--paulr

http://llvm-reviews.chandlerc.com/D2369

[probinson]

zzzzzzzzzz PING! zzzzzzzzzz

[probinson]

Ping....

I tried to ping this from inside Phab but I'm not seeing the
notice show up on llvm-commits. Somehow Phab and I just don't
get along very well.
--paulr

-----Original Message-----
From: [e-mail] [mailto:llvm-commits-
[e-mail]] On Behalf Of Paul Robinson
Sent: Tuesday, January 14, 2014 4:01 PM
To: [e-mail]
Subject: Re: [PATCH] Disable passes on optnone functions

probinson added you to the CC list for the revision "Disable passes on
optnone functions".

Hi chandlerc,

Functions marked 'optnone' should not be optimized. Per Chandler's
request, we avoided adding new attributes that Pass Manager would have
to be aware of, and had each pass individually ignore 'optnone'
functions.

http://llvm-reviews.chandlerc.com/D2369

Files:

lib/IR/LegacyPassManager.cpp
lib/Analysis/LoopPass.cpp
lib/Transforms/Scalar/JumpThreading.cpp
lib/Transforms/Scalar/Reassociate.cpp
lib/Transforms/Scalar/SimplifyCFGPass.cpp
lib/Transforms/Scalar/DeadStoreElimination.cpp
lib/Transforms/Scalar/SROA.cpp
lib/Transforms/Scalar/EarlyCSE.cpp
lib/Transforms/Scalar/ADCE.cpp
lib/Transforms/Scalar/MemCpyOptimizer.cpp
lib/Transforms/Scalar/TailRecursionElimination.cpp
lib/Transforms/Scalar/ScalarReplAggregates.cpp
lib/Transforms/Scalar/CorrelatedValuePropagation.cpp
lib/Transforms/Scalar/SCCP.cpp
lib/Transforms/Scalar/GVN.cpp
lib/Transforms/Scalar/DCE.cpp
lib/Transforms/InstCombine/InstructionCombining.cpp
lib/Transforms/Vectorize/SLPVectorizer.cpp
lib/Transforms/Utils/LowerExpectIntrinsic.cpp
lib/CodeGen/IfConversion.cpp
lib/CodeGen/MachineLICM.cpp
lib/CodeGen/PeepholeOptimizer.cpp
lib/CodeGen/ProcessImplicitDefs.cpp
lib/CodeGen/TailDuplication.cpp
lib/CodeGen/EarlyIfConversion.cpp
lib/CodeGen/DeadMachineInstructionElim.cpp
lib/CodeGen/BranchFolding.cpp
lib/CodeGen/OptimizePHIs.cpp
lib/CodeGen/MachineSink.cpp
lib/CodeGen/MachineCSE.cpp
lib/CodeGen/MachineCopyPropagation.cpp
test/Transforms/FunctionAttrs/optnone.ll

[nlewycky]

Please split the patch in two, one for changes to IR-level passes and pass manager (which should land first -- that should help disambiguate when there are pieces that both depend on), one for the codegen changes.

I'm unsure about the codegen changes here. You're adding a test at the beginning of "runOnMachineFunction" to each machine-level pass. The machine level requires a fixed set of passes to work in a certain way, you can't just disable some passes and expect it to work, the way you can with the IR-level passes.

The rationale for making the passes individually disable themselves on optnone is because some passes need to ignore optnone -- the always-inliner for example.

The test probably ought to go into test/Feature/optnone.ll ? Running -O1 and -O2, and opt and llc, it's not really testing the functionattrs pass.

I've reviewed everything except for lib/CodeGen/* and consider it good to commit. Sorry for the delays in review!

lib/Analysis/LoopPass.cpp

180

This is a pass manager?

lib/IR/LegacyPassManager.cpp

1292

I thought you weren't going to add it to pass managers but to individual passes? This is a pass manager.

[probinson]

-----Original Message-----
From: Nick Lewycky [mailto:[e-mail]]
Sent: Wednesday, January 29, 2014 4:02 PM
To: [e-mail]; Robinson, Paul
Cc: [e-mail]; [e-mail]; [e-mail]
Subject: Re: [PATCH] Disable passes on optnone functions

Please split the patch in two, one for changes to IR-level passes and

pass manager (which should land first -- that should help disambiguate
when there are pieces that both depend on), one for the codegen changes.

Okay. New patches coming, although it may take a little while, see
the comments below re. loop and basic-block testing.

I'm unsure about the codegen changes here. You're adding a test at the

beginning of "runOnMachineFunction" to each machine-level pass. The
machine level requires a fixed set of passes to work in a certain way,
you can't just disable some passes and expect it to work, the way you
can with the IR-level passes.

Let me get the revised IR-level patch done, then we can get back to the
machine-level part.

The rationale for making the passes individually disable themselves on

optnone is because some passes need to ignore optnone -- the always-
inliner for example.

The test probably ought to go into test/Feature/optnone.ll ? Running -

O1 and -O2, and opt and llc, it's not really testing the functionattrs
pass.

Okay, I misunderstood the intent of test/Transforms/FunctionAttrs.

I've reviewed everything except for lib/CodeGen/* and consider it good

to commit. Sorry for the delays in review!

Thanks for doing it! Now my plans for the next social can change
from "bring a laptop and two goons to make somebody review this" to
"lemme buy you a drink." :-)

Comment at: lib/IR/LegacyPassManager.cpp:1292
@@ -1291,1 +1291,3 @@

return false;

+ if (F.hasFnAttribute(Attribute::OptimizeNone)) {

+ DEBUG(dbgs() << "Skipping pass '" << getPassName()

I thought you weren't going to add it to pass managers but to individual
passes? This is a pass manager.

Comment at: lib/Analysis/LoopPass.cpp:180
@@ -179,1 +179,3 @@
bool LPPassManager::runOnFunction(Function &F) {
+ if (F.hasFnAttribute(Attribute::OptimizeNone)) {

+ DEBUG(dbgs() << "Skipping pass '" << getPassName()

This is a pass manager?

BBPassManager and LPPassManager are themselves function passes.
I disabled the function passes that are the collection of basic-block
passes and the collection of loop passes, respectively, on the theory
that optnone is a function-level attribute. However, I can see given
events such as Chandler's recent conversion of a loop pass to a
function pass that disabling the passes individually could be safer.

I've worked out how to find the function attributes from a basic
block or loop. However it's really not feasible (AFAICT) to print out
a "skipping" diagnostic once per function, if the passes are disabled
at the loop or basic block level. That will make testing these things
distinctly more tedious; basically I'll have to take a functional test
for each optimization, slap 'optnone' on it, and verify that the
optimization did NOT happen. So it may take a little while before I
can turn in revised patches.

http://llvm-reviews.chandlerc.com/D2369

Thanks,
--paulr

[probinson]

Revised patch for IR-level passes attached. I got tired of
pasting the debug diagnostic so I factored the real work into
the pass base classes. For function and basic-block passes I
can make the debug output appear only once per function; didn't
see a good way to do that for loop passes. Not really critical.
Debug output does make it pretty easy to test. I also threw
in a check that optnone doesn't suppress anything at -O0.

Let's get this done and then I'll take another look at all the
machine-function passes.
Thanks,
--paulr

-----Original Message-----
From: [e-mail] [mailto:llvm-commits-
[e-mail]] On Behalf Of Robinson, Paul
Sent: Thursday, January 30, 2014 2:30 PM
To: [e-mail];
[e-mail]
Cc: [e-mail]
Subject: RE: [PATCH] Disable passes on optnone functions

-----Original Message-----
From: Nick Lewycky [mailto:[e-mail]]
Sent: Wednesday, January 29, 2014 4:02 PM
To: [e-mail]; Robinson, Paul
Cc: [e-mail]; [e-mail]; [e-mail]
Subject: Re: [PATCH] Disable passes on optnone functions

Please split the patch in two, one for changes to IR-level passes

and

pass manager (which should land first -- that should help disambiguate
when there are pieces that both depend on), one for the codegen

changes.

Okay. New patches coming, although it may take a little while, see
the comments below re. loop and basic-block testing.

I'm unsure about the codegen changes here. You're adding a test at

the

beginning of "runOnMachineFunction" to each machine-level pass. The
machine level requires a fixed set of passes to work in a certain way,
you can't just disable some passes and expect it to work, the way you
can with the IR-level passes.

Let me get the revised IR-level patch done, then we can get back to the
machine-level part.

The rationale for making the passes individually disable themselves

on

optnone is because some passes need to ignore optnone -- the always-
inliner for example.

The test probably ought to go into test/Feature/optnone.ll ? Running

O1 and -O2, and opt and llc, it's not really testing the functionattrs
pass.

Okay, I misunderstood the intent of test/Transforms/FunctionAttrs.

I've reviewed everything except for lib/CodeGen/* and consider it

good

to commit. Sorry for the delays in review!

Thanks for doing it! Now my plans for the next social can change
from "bring a laptop and two goons to make somebody review this" to
"lemme buy you a drink." :-)

Comment at: lib/IR/LegacyPassManager.cpp:1292
@@ -1291,1 +1291,3 @@

return false;

+ if (F.hasFnAttribute(Attribute::OptimizeNone)) {

+ DEBUG(dbgs() << "Skipping pass '" << getPassName()

I thought you weren't going to add it to pass managers but to

individual

passes? This is a pass manager.

Comment at: lib/Analysis/LoopPass.cpp:180
@@ -179,1 +179,3 @@
bool LPPassManager::runOnFunction(Function &F) {
+ if (F.hasFnAttribute(Attribute::OptimizeNone)) {

+ DEBUG(dbgs() << "Skipping pass '" << getPassName()

This is a pass manager?

BBPassManager and LPPassManager are themselves function passes.
I disabled the function passes that are the collection of basic-block
passes and the collection of loop passes, respectively, on the theory
that optnone is a function-level attribute. However, I can see given
events such as Chandler's recent conversion of a loop pass to a
function pass that disabling the passes individually could be safer.

I've worked out how to find the function attributes from a basic
block or loop. However it's really not feasible (AFAICT) to print out
a "skipping" diagnostic once per function, if the passes are disabled
at the loop or basic block level. That will make testing these things
distinctly more tedious; basically I'll have to take a functional test
for each optimization, slap 'optnone' on it, and verify that the
optimization did NOT happen. So it may take a little while before I
can turn in revised patches.

http://llvm-reviews.chandlerc.com/D2369

Thanks,
--paulr

---

llvm-commits mailing list
[e-mail]
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits

[probinson]

-----Original Message-----
From: Robinson, Paul
Sent: Monday, February 03, 2014 2:15 PM
To: Robinson, Paul; reviews+D2369+public+3a7363072c7f178d@llvm-
reviews.chandlerc.com; [e-mail]
Cc: [e-mail]
Subject: RE: [PATCH] Disable passes on optnone functions

Revised patch for IR-level passes attached.

Right. NOW they are attached.

I got tired of
pasting the debug diagnostic so I factored the real work into
the pass base classes. For function and basic-block passes I
can make the debug output appear only once per function; didn't
see a good way to do that for loop passes. Not really critical.
Debug output does make it pretty easy to test. I also threw
in a check that optnone doesn't suppress anything at -O0.

Let's get this done and then I'll take another look at all the
machine-function passes.
Thanks,
--paulr

-----Original Message-----
From: [e-mail] [mailto:llvm-commits-
[e-mail]] On Behalf Of Robinson, Paul
Sent: Thursday, January 30, 2014 2:30 PM
To: [e-mail];
[e-mail]
Cc: [e-mail]
Subject: RE: [PATCH] Disable passes on optnone functions

-----Original Message-----
From: Nick Lewycky [mailto:[e-mail]]
Sent: Wednesday, January 29, 2014 4:02 PM
To: [e-mail]; Robinson, Paul
Cc: [e-mail]; [e-mail]; [e-mail]
Subject: Re: [PATCH] Disable passes on optnone functions

Please split the patch in two, one for changes to IR-level passes

and

pass manager (which should land first -- that should help

disambiguate

when there are pieces that both depend on), one for the codegen

changes.

Okay. New patches coming, although it may take a little while, see
the comments below re. loop and basic-block testing.

I'm unsure about the codegen changes here. You're adding a test at

the

beginning of "runOnMachineFunction" to each machine-level pass. The
machine level requires a fixed set of passes to work in a certain

way,

you can't just disable some passes and expect it to work, the way

you

can with the IR-level passes.

Let me get the revised IR-level patch done, then we can get back to

the

machine-level part.

The rationale for making the passes individually disable

themselves

on

optnone is because some passes need to ignore optnone -- the always-
inliner for example.

The test probably ought to go into test/Feature/optnone.ll ?

Running

O1 and -O2, and opt and llc, it's not really testing the

functionattrs

pass.

Okay, I misunderstood the intent of test/Transforms/FunctionAttrs.

I've reviewed everything except for lib/CodeGen/* and consider it

good

to commit. Sorry for the delays in review!

Thanks for doing it! Now my plans for the next social can change
from "bring a laptop and two goons to make somebody review this" to
"lemme buy you a drink." :-)

Comment at: lib/IR/LegacyPassManager.cpp:1292
@@ -1291,1 +1291,3 @@

return false;

+ if (F.hasFnAttribute(Attribute::OptimizeNone)) {

+ DEBUG(dbgs() << "Skipping pass '" << getPassName()

I thought you weren't going to add it to pass managers but to

individual

passes? This is a pass manager.

Comment at: lib/Analysis/LoopPass.cpp:180
@@ -179,1 +179,3 @@
bool LPPassManager::runOnFunction(Function &F) {
+ if (F.hasFnAttribute(Attribute::OptimizeNone)) {

+ DEBUG(dbgs() << "Skipping pass '" << getPassName()

This is a pass manager?

BBPassManager and LPPassManager are themselves function passes.
I disabled the function passes that are the collection of basic-block
passes and the collection of loop passes, respectively, on the theory
that optnone is a function-level attribute. However, I can see given
events such as Chandler's recent conversion of a loop pass to a
function pass that disabling the passes individually could be safer.

I've worked out how to find the function attributes from a basic
block or loop. However it's really not feasible (AFAICT) to print out
a "skipping" diagnostic once per function, if the passes are disabled
at the loop or basic block level. That will make testing these things
distinctly more tedious; basically I'll have to take a functional test
for each optimization, slap 'optnone' on it, and verify that the
optimization did NOT happen. So it may take a little while before I
can turn in revised patches.

http://llvm-reviews.chandlerc.com/D2369

Thanks,
--paulr

---

llvm-commits mailing list
[e-mail]
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits

• {F31726, layout=link}

[chandlerc]

Pretty sure this is obsolete.

[probinson]

In D2369#148431, @chandlerc wrote:

Pretty sure this is obsolete.

Well, ultimately the revised content of this patch landed in r200892. The email record exists if you want to look at it, circa Feb 5 2014.
But by that time it was clear Phabricator hated me and I had stopped trying to do anything with it.
More recently I've been persuaded to try it again, and a few basic things do seem to work okay.

Phab's "help" is astoundingly un-helpful. If there's something you actually want me to _do_ here, please (a) point me to a Phab help page that describes it, or (b) explain in enough detail that I can document it on LLVM's Phab page.
Thanks,
--paulr

[dblaikie]

The little "comment" dropdown above the comment box (the one at the bottom
of the review, after all the diff changes) has an "abandon" option, which I
think is what we're doing for code reviews that end up not going anywhere.

(there's also a "close" option too, I'm not sure of the distinction)

Maybe we should be using whatever feature this refers to:
https://secure.phabricator.com/T4720 so that we can all just mark code
reviews as abandoned, rather than requesting the original author do so.

[probinson]

In D2369#148975, @dblaikie wrote:

The little "comment" dropdown above the comment box (the one at the bottom
of the review, after all the diff changes) has an "abandon" option, which I
think is what we're doing for code reviews that end up not going anywhere.

Okay, I see that. But in fact this review did "go somewhere" and a later version
of the patch was actually committed. So "abandon" is semantically wrong, even
if it would do something to cause it to not be on lists of open reviews.
(BTW I am completely sympathetic about getting it off lists of open reviews.
I'm just at a loss for how to navigate this, shall we say, help-challenged product.)

(there's also a "close" option too, I'm not sure of the distinction)

Not seeing that in the drop-down list of Actions, where is that?

[probinson]

A later edition of this patch was handled on the email thread, rather than directly in Phabricator, approved by Nick Lewycky and committed as r200892.
I'm trying to persuade Phabricator to close out the review to tidy things up.

[probinson]

After "accepting," Phab will now let me "close" the review.

lib/Analysis/LoopPass.cpp

void LPPassManager::getAnalysisUsage(AnalysisUsage &Info) const {
   // become part of LPPassManager.
   Info.addRequired<LoopInfo>();
   Info.setPreservesAll();
 }
 
 /// run - Execute all of the passes scheduled for execution.  Keep track of
 /// whether any of the passes modifies the function, and if so, return true.
 bool LPPassManager::runOnFunction(Function &F) {
+  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << F.getName() << "\n");
+    return false;
+  }
+
   LI = &getAnalysis<LoopInfo>();
   bool Changed = false;
 
   // Collect inherited analysis from Module level pass manager.
   populateInheritedAnalysis(TPM->activeStack);
 
   // Populate the loop queue in reverse program order. There is no clear need to
   // process sibling loops in either forward or reverse order. There may be some

lib/CodeGen/BranchFolding.cpp

 
 char BranchFolderPass::ID = 0;
 char &llvm::BranchFolderPassID = BranchFolderPass::ID;
 
 INITIALIZE_PASS(BranchFolderPass, "branch-folder",
                 "Control Flow Optimizer", false, false)
 
 bool BranchFolderPass::runOnMachineFunction(MachineFunction &MF) {
+  if (MF.getFunction()->hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << MF.getName() << "\n");
+    return false;
+  }
+
   TargetPassConfig *PassConfig = &getAnalysis<TargetPassConfig>();
   // TailMerge can create jump into if branches that make CFG irreducible for
   // HW that requires structurized CFG.
   bool EnableTailMerge = !MF.getTarget().requiresStructuredCFG() &&
       PassConfig->getEnableTailMerge();
   BranchFolder Folder(EnableTailMerge, /*CommonHoist=*/true);
   return Folder.OptimizeFunction(MF,
                                  MF.getTarget().getInstrInfo(),

lib/CodeGen/DeadMachineInstructionElim.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "codegen-dce"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/IR/Function.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetMachine.h"
 using namespace llvm;
 
 STATISTIC(NumDeletes,          "Number of dead instructions deleted");
for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
     }
   }
 
   // If there are no defs with uses, the instruction is dead.
   return true;
 }
 
 bool DeadMachineInstructionElim::runOnMachineFunction(MachineFunction &MF) {
+  if (MF.getFunction()->hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << MF.getName() << "\n");
+    return false;
+  }
+
   bool AnyChanges = false;
   MRI = &MF.getRegInfo();
   TRI = MF.getTarget().getRegisterInfo();
   TII = MF.getTarget().getInstrInfo();
 
   // Loop over all instructions in all blocks, from bottom to top, so that it's
   // more likely that chains of dependent but ultimately dead instructions will
   // be cleaned up.

lib/CodeGen/EarlyIfConversion.cpp

while (IfConv.canConvertIf(MBB) && shouldConvertIf()) {
     Changed = true;
     updateDomTree(RemovedBlocks);
     updateLoops(RemovedBlocks);
   }
   return Changed;
 }
 
 bool EarlyIfConverter::runOnMachineFunction(MachineFunction &MF) {
+  if (MF.getFunction()->hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << MF.getName() << "\n");
+    return false;
+  }
+
   DEBUG(dbgs() << "********** EARLY IF-CONVERSION **********\n"
                << "********** Function: " << MF.getName() << '\n');
   TII = MF.getTarget().getInstrInfo();
   TRI = MF.getTarget().getRegisterInfo();
   SchedModel =
     MF.getTarget().getSubtarget<TargetSubtargetInfo>().getSchedModel();
   MRI = &MF.getRegInfo();
   DomTree = &getAnalysis<MachineDominatorTree>();

lib/CodeGen/IfConversion.cpp

 #include "llvm/ADT/Statistic.h"
 #include "llvm/CodeGen/LivePhysRegs.h"
 #include "llvm/CodeGen/MachineBranchProbabilityInfo.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/TargetSchedule.h"
+#include "llvm/IR/Function.h"
 #include "llvm/MC/MCInstrItineraries.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetLowering.h"
 #include "llvm/Target/TargetMachine.h"

 
 char &llvm::IfConverterID = IfConverter::ID;
 
 INITIALIZE_PASS_BEGIN(IfConverter, "if-converter", "If Converter", false, false)
 INITIALIZE_PASS_DEPENDENCY(MachineBranchProbabilityInfo)
 INITIALIZE_PASS_END(IfConverter, "if-converter", "If Converter", false, false)
 
 bool IfConverter::runOnMachineFunction(MachineFunction &MF) {
+  if (MF.getFunction()->hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << MF.getName() << "\n");
+    return false;
+  }
+
   TLI = MF.getTarget().getTargetLowering();
   TII = MF.getTarget().getInstrInfo();
   TRI = MF.getTarget().getRegisterInfo();
   MBPI = &getAnalysis<MachineBranchProbabilityInfo>();
   MRI = &MF.getRegInfo();
 
   const TargetSubtargetInfo &ST =
     MF.getTarget().getSubtarget<TargetSubtargetInfo>();

lib/CodeGen/MachineCSE.cpp

for (unsigned i = 0, e = Scopes.size(); i != e; ++i) {
     // If it's a leaf node, it's done. Traverse upwards to pop ancestors.
     ExitScopeIfDone(Node, OpenChildren);
   }
 
   return Changed;
 }
 
 bool MachineCSE::runOnMachineFunction(MachineFunction &MF) {
+  if (MF.getFunction()->hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << MF.getName() << "\n");
+    return false;
+  }
+
   TII = MF.getTarget().getInstrInfo();
   TRI = MF.getTarget().getRegisterInfo();
   MRI = &MF.getRegInfo();
   AA = &getAnalysis<AliasAnalysis>();
   DT = &getAnalysis<MachineDominatorTree>();
   return PerformCSE(DT->getRootNode());
 }

lib/CodeGen/MachineCopyPropagation.cpp

 #include "llvm/CodeGen/Passes.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/IR/Function.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 using namespace llvm;
 
for (SmallSetVector<MachineInstr*, 8>::iterator
       }
     }
   }
 
   return Changed;
 }
 
 bool MachineCopyPropagation::runOnMachineFunction(MachineFunction &MF) {
+  if (MF.getFunction()->hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << MF.getName() << "\n");
+    return false;
+  }
+
   bool Changed = false;
 
   TRI = MF.getTarget().getRegisterInfo();
   TII = MF.getTarget().getInstrInfo();
   MRI = &MF.getRegInfo();
 
   for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I)
     Changed |= CopyPropagateBlock(*I);
 
   return Changed;
 }

lib/CodeGen/MachineLICM.cpp

static bool LoopIsOuterMostWithPredecessor(MachineLoop *CurLoop) {
   for (MachineLoop *L = CurLoop->getParentLoop(); L; L = L->getParentLoop())
     if (L->getLoopPredecessor())
       return false;
   // None of them did, so this is the outermost with a unique predecessor.
   return true;
 }
 
 bool MachineLICM::runOnMachineFunction(MachineFunction &MF) {
+  if (MF.getFunction()->hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << MF.getName() << "\n");
+    return false;
+  }
+
   Changed = FirstInLoop = false;
   TM = &MF.getTarget();
   TII = TM->getInstrInfo();
   TLI = TM->getTargetLowering();
   TRI = TM->getRegisterInfo();
   MFI = MF.getFrameInfo();
   MRI = &MF.getRegInfo();
   InstrItins = TM->getInstrItineraryData();

lib/CodeGen/MachineSink.cpp

for (MachineRegisterInfo::use_nodbg_iterator
     if (!DT->dominates(MBB, UseBlock))
       return false;
   }
 
   return true;
 }
 
 bool MachineSinking::runOnMachineFunction(MachineFunction &MF) {
+  if (MF.getFunction()->hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << MF.getName() << "\n");
+    return false;
+  }
+
   DEBUG(dbgs() << "******** Machine Sinking ********\n");
 
   const TargetMachine &TM = MF.getTarget();
   TII = TM.getInstrInfo();
   TRI = TM.getRegisterInfo();
   MRI = &MF.getRegInfo();
   DT = &getAnalysis<MachineDominatorTree>();
   LI = &getAnalysis<MachineLoopInfo>();

lib/CodeGen/OptimizePHIs.cpp

 #define DEBUG_TYPE "phi-opt"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/IR/Function.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Target/TargetInstrInfo.h"
 using namespace llvm;
 
 STATISTIC(NumPHICycles, "Number of PHI cycles replaced");
 STATISTIC(NumDeadPHICycles, "Number of dead PHI cycles");
 
 namespace {
   class OptimizePHIs : public MachineFunctionPass {

 }
 
 char OptimizePHIs::ID = 0;
 char &llvm::OptimizePHIsID = OptimizePHIs::ID;
 INITIALIZE_PASS(OptimizePHIs, "opt-phis",
                 "Optimize machine instruction PHIs", false, false)
 
 bool OptimizePHIs::runOnMachineFunction(MachineFunction &Fn) {
+  if (Fn.getFunction()->hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << Fn.getName() << "\n");
+    return false;
+  }
+
   MRI = &Fn.getRegInfo();
   TII = Fn.getTarget().getInstrInfo();
 
   // Find dead PHI cycles and PHI cycles that can be replaced by a single
   // value.  InstCombine does these optimizations, but DAG legalization may
   // introduce new opportunities, e.g., when i64 values are split up for
   // 32-bit targets.
   bool Changed = false;

lib/CodeGen/PeepholeOptimizer.cpp

if (TII->FoldImmediate(MI, II->second, Reg, MRI)) {
       ++NumImmFold;
       return true;
     }
   }
   return false;
 }
 
 bool PeepholeOptimizer::runOnMachineFunction(MachineFunction &MF) {
+  if (MF.getFunction()->hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << MF.getName() << "\n");
+    return false;
+  }
+
   DEBUG(dbgs() << "********** PEEPHOLE OPTIMIZER **********\n");
   DEBUG(dbgs() << "********** Function: " << MF.getName() << '\n');
 
   if (DisablePeephole)
     return false;
 
   TM  = &MF.getTarget();
   TII = TM->getInstrInfo();

lib/CodeGen/ProcessImplicitDefs.cpp

 #define DEBUG_TYPE "processimplicitdefs"
 
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/Passes.h"
+#include "llvm/IR/Function.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetInstrInfo.h"
 
 using namespace llvm;
 
 namespace {
 /// Process IMPLICIT_DEF instructions and make sure there is one implicit_def
void ProcessImplicitDefs::processImplicitDef(MachineInstr *MI) {
   for (unsigned i = MI->getNumOperands() - 1; i; --i)
     MI->RemoveOperand(i);
   DEBUG(dbgs() << "Keeping physreg: " << *MI);
 }
 
 /// processImplicitDefs - Process IMPLICIT_DEF instructions and turn them into
 /// <undef> operands.
 bool ProcessImplicitDefs::runOnMachineFunction(MachineFunction &MF) {
+  if (MF.getFunction()->hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << MF.getName() << "\n");
+    return false;
+  }
 
   DEBUG(dbgs() << "********** PROCESS IMPLICIT DEFS **********\n"
                << "********** Function: " << MF.getName() << '\n');
 
   bool Changed = false;
 
   TII = MF.getTarget().getInstrInfo();
   TRI = MF.getTarget().getRegisterInfo();

lib/CodeGen/TailDuplication.cpp

 }
 
 char &llvm::TailDuplicateID = TailDuplicatePass::ID;
 
 INITIALIZE_PASS(TailDuplicatePass, "tailduplication", "Tail Duplication",
                 false, false)
 
 bool TailDuplicatePass::runOnMachineFunction(MachineFunction &MF) {
+  if (MF.getFunction()->hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << MF.getName() << "\n");
+    return false;
+  }
+
   TII = MF.getTarget().getInstrInfo();
   TRI = MF.getTarget().getRegisterInfo();
   MRI = &MF.getRegInfo();
   MMI = getAnalysisIfAvailable<MachineModuleInfo>();
   PreRegAlloc = MRI->isSSA();
   RS.reset();
   if (MRI->tracksLiveness() && TRI->trackLivenessAfterRegAlloc(MF))
     RS.reset(new RegScavenger());

lib/IR/LegacyPassManager.cpp

 // BBPassManager implementation
 
 /// Execute all of the passes scheduled for execution by invoking
 /// runOnBasicBlock method.  Keep track of whether any of the passes modifies
 /// the function, and if so, return true.
 bool BBPassManager::runOnFunction(Function &F) {
   if (F.isDeclaration())
     return false;
+  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << F.getName() << "\n");
+    return false;
+  }
 
   bool Changed = doInitialization(F);
 
   for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
     for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
       BasicBlockPass *BP = getContainedPass(Index);
       bool LocalChanged = false;
 

lib/Transforms/InstCombine/InstructionCombining.cpp

public:
   /// can be defined in terms of the instruction combiner framework.
   virtual void replaceAllUsesWith(Instruction *I, Value *With) const {
     IC->ReplaceInstUsesWith(*I, With);
   }
 };
 }
 
 bool InstCombiner::runOnFunction(Function &F) {
+  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << F.getName() << "\n");
+    return false;
+  }
+
   TD = getAnalysisIfAvailable<DataLayout>();
   TLI = &getAnalysis<TargetLibraryInfo>();
   // Minimizing size?
   MinimizeSize = F.getAttributes().hasAttribute(AttributeSet::FunctionIndex,
                                                 Attribute::MinSize);
 
   /// Builder - This is an IRBuilder that automatically inserts new
   /// instructions into the worklist when they are created.

lib/Transforms/Scalar/ADCE.cpp

 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CFG.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/InstIterator.h"
 using namespace llvm;
 
 STATISTIC(NumRemoved, "Number of instructions removed");
 
 namespace {
   struct ADCE : public FunctionPass {
     static char ID; // Pass identification, replacement for typeid
namespace {
 
   };
 }
 
 char ADCE::ID = 0;
 INITIALIZE_PASS(ADCE, "adce", "Aggressive Dead Code Elimination", false, false)
 
 bool ADCE::runOnFunction(Function& F) {
+  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << F.getName() << "\n");
+    return false;
+  }
+
   SmallPtrSet<Instruction*, 128> alive;
   SmallVector<Instruction*, 128> worklist;
 
   // Collect the set of "root" instructions that are known live.
   for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I)
     if (isa<TerminatorInst>(I.getInstructionIterator()) ||
         isa<DbgInfoIntrinsic>(I.getInstructionIterator()) ||
         isa<LandingPadInst>(I.getInstructionIterator()) ||

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

if (Changed)
     // If the switch has been simplified to the point where it can be replaced
     // by a branch then do so now.
     ConstantFoldTerminator(BB);
 
   return Changed;
 }
 
 bool CorrelatedValuePropagation::runOnFunction(Function &F) {
+  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << F.getName() << "\n");
+    return false;
+  }
+
   LVI = &getAnalysis<LazyValueInfo>();
 
   bool FnChanged = false;
 
   for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE; ++FI) {
     bool BBChanged = false;
     for (BasicBlock::iterator BI = FI->begin(), BE = FI->end(); BI != BE; ) {
       Instruction *II = BI++;

lib/Transforms/Scalar/DCE.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "dce"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/Pass.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/InstIterator.h"
 #include "llvm/Target/TargetLibraryInfo.h"
 #include "llvm/Transforms/Utils/Local.h"
 using namespace llvm;
 
 STATISTIC(DIEEliminated, "Number of insts removed by DIE pass");
 STATISTIC(DCEEliminated, "Number of insts removed");
 
struct DCE : public FunctionPass {
     }
  };
 }
 
 char DCE::ID = 0;
 INITIALIZE_PASS(DCE, "dce", "Dead Code Elimination", false, false)
 
 bool DCE::runOnFunction(Function &F) {
+  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << F.getName() << "\n");
+    return false;
+  }
+
   TargetLibraryInfo *TLI = getAnalysisIfAvailable<TargetLibraryInfo>();
 
   // Start out with all of the instructions in the worklist...
   std::vector<Instruction*> WorkList;
   for (inst_iterator i = inst_begin(F), e = inst_end(F); i != e; ++i)
     WorkList.push_back(&*i);
 
   // Loop over the worklist finding instructions that are dead.  If they are

lib/Transforms/Scalar/DeadStoreElimination.cpp

struct DSE : public FunctionPass {
     const TargetLibraryInfo *TLI;
 
     static char ID; // Pass identification, replacement for typeid
     DSE() : FunctionPass(ID), AA(0), MD(0), DT(0) {
       initializeDSEPass(*PassRegistry::getPassRegistry());
     }
 
     virtual bool runOnFunction(Function &F) {
+      if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+        DEBUG(dbgs() << "Skipping pass '" << getPassName()
+              << "' on function " << F.getName() << "\n");
+        return false;
+      }
+
       AA = &getAnalysis<AliasAnalysis>();
       MD = &getAnalysis<MemoryDependenceAnalysis>();
       DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
       TLI = AA->getTargetLibraryInfo();
 
       bool Changed = false;
       for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
         // Only check non-dead blocks.  Dead blocks may have strange pointer

lib/Transforms/Scalar/EarlyCSE.cpp

for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) {
     }
   }
 
   return Changed;
 }
 
 
 bool EarlyCSE::runOnFunction(Function &F) {
+  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << F.getName() << "\n");
+    return false;
+  }
+
   std::vector<StackNode *> nodesToProcess;
 
   TD = getAnalysisIfAvailable<DataLayout>();
   TLI = &getAnalysis<TargetLibraryInfo>();
   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
 
   // Tables that the pass uses when walking the domtree.
   ScopedHTType AVTable;

lib/Transforms/Scalar/GVN.cpp

bool GVN::processInstruction(Instruction *I) {
   if (MD && repl->getType()->getScalarType()->isPointerTy())
     MD->invalidateCachedPointerInfo(repl);
   markInstructionForDeletion(I);
   return true;
 }
 
 /// runOnFunction - This is the main transformation entry point for a function.
 bool GVN::runOnFunction(Function& F) {
+  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << F.getName() << "\n");
+    return false;
+  }
+
   if (!NoLoads)
     MD = &getAnalysis<MemoryDependenceAnalysis>();
   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   TD = getAnalysisIfAvailable<DataLayout>();
   TLI = &getAnalysis<TargetLibraryInfo>();
   VN.setAliasAnalysis(&getAnalysis<AliasAnalysis>());
   VN.setMemDep(MD);
   VN.setDomTree(DT);

lib/Transforms/Scalar/JumpThreading.cpp

INITIALIZE_PASS_END(JumpThreading, "jump-threading",
                 "Jump Threading", false, false)
 
 // Public interface to the Jump Threading pass
 FunctionPass *llvm::createJumpThreadingPass() { return new JumpThreading(); }
 
 /// runOnFunction - Top level algorithm.
 ///
 bool JumpThreading::runOnFunction(Function &F) {
+  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << F.getName() << "\n");
+    return false;
+  }
+
   DEBUG(dbgs() << "Jump threading on function '" << F.getName() << "'\n");
   TD = getAnalysisIfAvailable<DataLayout>();
   TLI = &getAnalysis<TargetLibraryInfo>();
   LVI = &getAnalysis<LazyValueInfo>();
 
   FindLoopHeaders(F);
 
   bool Changed, EverChanged = false;

lib/Transforms/Scalar/MemCpyOptimizer.cpp

bool MemCpyOpt::iterateOnFunction(Function &F) {
 
   return MadeChange;
 }
 
 // MemCpyOpt::runOnFunction - This is the main transformation entry point for a
 // function.
 //
 bool MemCpyOpt::runOnFunction(Function &F) {
+  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << F.getName() << "\n");
+    return false;
+  }
+
   bool MadeChange = false;
   MD = &getAnalysis<MemoryDependenceAnalysis>();
   TD = getAnalysisIfAvailable<DataLayout>();
   TLI = &getAnalysis<TargetLibraryInfo>();
 
   // If we don't have at least memset and memcpy, there is little point of doing
   // anything here.  These are required by a freestanding implementation, so if
   // even they are disabled, there is no point in trying hard.

lib/Transforms/Scalar/Reassociate.cpp

void Reassociate::ReassociateExpression(BinaryOperator *I) {
   }
 
   // Now that we ordered and optimized the expressions, splat them back into
   // the expression tree, removing any unneeded nodes.
   RewriteExprTree(I, Ops);
 }
 
 bool Reassociate::runOnFunction(Function &F) {
+  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << F.getName() << "\n");
+    return false;
+  }
+
   // Calculate the rank map for F
   BuildRankMap(F);
 
   MadeChange = false;
   for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI) {
     // Optimize every instruction in the basic block.
     for (BasicBlock::iterator II = BI->begin(), IE = BI->end(); II != IE; )
       if (isInstructionTriviallyDead(II)) {

lib/Transforms/Scalar/SCCP.cpp

while (EndInst != BB->begin()) {
     ++NumInstRemoved;
   }
 }
 
 // runOnFunction() - Run the Sparse Conditional Constant Propagation algorithm,
 // and return true if the function was modified.
 //
 bool SCCP::runOnFunction(Function &F) {
+  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << F.getName() << "\n");
+    return false;
+  }
+
   DEBUG(dbgs() << "SCCP on function '" << F.getName() << "'\n");
   const DataLayout *TD = getAnalysisIfAvailable<DataLayout>();
   const TargetLibraryInfo *TLI = &getAnalysis<TargetLibraryInfo>();
   SCCPSolver Solver(TD, TLI);
 
   // Mark the first block of the function as being executable.
   Solver.MarkBlockExecutable(F.begin());
 

lib/Transforms/Scalar/SROA.cpp

public:
     typedef AllocaInst *argument_type;
 
     IsAllocaInSet(const SetType &Set) : Set(Set) {}
     bool operator()(AllocaInst *AI) const { return Set.count(AI); }
   };
 }
 
 bool SROA::runOnFunction(Function &F) {
+  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << F.getName() << "\n");
+    return false;
+  }
+
   DEBUG(dbgs() << "SROA function: " << F.getName() << "\n");
   C = &F.getContext();
   DL = getAnalysisIfAvailable<DataLayout>();
   if (!DL) {
     DEBUG(dbgs() << "  Skipping SROA -- no target data!\n");
     return false;
   }
   DominatorTreeWrapperPass *DTWP =

lib/Transforms/Scalar/ScalarReplAggregates.cpp

 
 
 //===----------------------------------------------------------------------===//
 // SRoA Driver
 //===----------------------------------------------------------------------===//
 
 
 bool SROA::runOnFunction(Function &F) {
+  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << F.getName() << "\n");
+    return false;
+  }
+
   TD = getAnalysisIfAvailable<DataLayout>();
 
   bool Changed = performPromotion(F);
 
   // FIXME: ScalarRepl currently depends on DataLayout more than it
   // theoretically needs to. It should be refactored in order to support
   // target-independent IR. Until this is done, just skip the actual
   // scalar-replacement portion of this pass.

lib/Transforms/Scalar/SimplifyCFGPass.cpp

 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CFG.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Transforms/Utils/Local.h"
 using namespace llvm;
 
 STATISTIC(NumSimpl, "Number of blocks simplified");
 
 namespace {
 struct CFGSimplifyPass : public FunctionPass {
   static char ID; // Pass identification, replacement for typeid
static bool iterativelySimplifyCFG(Function &F, const TargetTransformInfo &TTI,
   }
   return Changed;
 }
 
 // It is possible that we may require multiple passes over the code to fully
 // simplify the CFG.
 //
 bool CFGSimplifyPass::runOnFunction(Function &F) {
+  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << F.getName() << "\n");
+    return false;
+  }
+
   const TargetTransformInfo &TTI = getAnalysis<TargetTransformInfo>();
   const DataLayout *TD = getAnalysisIfAvailable<DataLayout>();
   bool EverChanged = removeUnreachableBlocks(F);
   EverChanged |= mergeEmptyReturnBlocks(F);
   EverChanged |= iterativelySimplifyCFG(F, TTI, TD);
 
   // If neither pass changed anything, we're done.
   if (!EverChanged) return false;

lib/Transforms/Scalar/TailRecursionElimination.cpp

struct AllocaCaptureTracker : public CaptureTracker {
   }
 
   bool Captured;
   SmallPtrSet<const Value *, 16> UsesAlloca;
 };
 } // end anonymous namespace
 
 bool TailCallElim::runOnFunction(Function &F) {
+  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << F.getName() << "\n");
+    return false;
+  }
+
   // If this function is a varargs function, we won't be able to PHI the args
   // right, so don't even try to convert it...
   if (F.getFunctionType()->isVarArg()) return false;
 
   TTI = &getAnalysis<TargetTransformInfo>();
   BasicBlock *OldEntry = 0;
   bool TailCallsAreMarkedTail = false;
   SmallVector<PHINode*, 8> ArgumentPHIs;

lib/Transforms/Utils/LowerExpectIntrinsic.cpp

bool LowerExpectIntrinsic::HandleIfExpect(BranchInst *BI) {
   BI->setMetadata(LLVMContext::MD_prof, Node);
 
   CmpI->setOperand(0, ArgValue);
   return true;
 }
 
 
 bool LowerExpectIntrinsic::runOnFunction(Function &F) {
+  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    DEBUG(dbgs() << "Skipping pass '" << getPassName()
+          << "' on function " << F.getName() << "\n");
+    return false;
+  }
+
   for (Function::iterator I = F.begin(), E = F.end(); I != E;) {
     BasicBlock *BB = I++;
 
     // Create "block_weights" metadata.
     if (BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator())) {
       if (HandleIfExpect(BI))
         IfHandled++;
     } else if (SwitchInst *SI = dyn_cast<SwitchInst>(BB->getTerminator())) {

lib/Transforms/Vectorize/SLPVectorizer.cpp

struct SLPVectorizer : public FunctionPass {
   ScalarEvolution *SE;
   DataLayout *DL;
   TargetTransformInfo *TTI;
   AliasAnalysis *AA;
   LoopInfo *LI;
   DominatorTree *DT;
 
   virtual bool runOnFunction(Function &F) {
+    if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+      DEBUG(dbgs() << "Skipping pass '" << getPassName()
+            << "' on function " << F.getName() << "\n");
+      return false;
+    }
+
     SE = &getAnalysis<ScalarEvolution>();
     DL = getAnalysisIfAvailable<DataLayout>();
     TTI = &getAnalysis<TargetTransformInfo>();
     AA = &getAnalysis<AliasAnalysis>();
     LI = &getAnalysis<LoopInfo>();
     DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
 
     StoreRefs.clear();

test/Transforms/FunctionAttrs/optnone.ll

+; RUN: opt -O1 -S -debug %s 2>&1 | FileCheck %s --check-prefix=OPT-O1
+; RUN: opt -O2 -S -debug %s 2>&1 | FileCheck %s --check-prefix=OPT-O1 --check-prefix=OPT-O2O3
+; RUN: opt -O3 -S -debug %s 2>&1 | FileCheck %s --check-prefix=OPT-O1 --check-prefix=OPT-O2O3
+; RUN: llc -O1 -debug %s -o /dev/null 2>&1 | FileCheck %s --check-prefix=LLC
+; RUN: llc -O2 -debug %s -o /dev/null 2>&1 | FileCheck %s --check-prefix=LLC
+; RUN: llc -O3 -debug %s -o /dev/null 2>&1 | FileCheck %s --check-prefix=LLC
+; REQUIRES: asserts
+
+; This test verifies that we don't run target independent optimizations
+; on optnone functions.
+
+; Function Attrs: noinline optnone
+define i32 @_Z3fooi(i32 %x) #0 {
+entry:
+  %x.addr = alloca i32, align 4
+  store i32 %x, i32* %x.addr, align 4
+  br label %while.cond
+
+while.cond:                                       ; preds = %while.body, %entry
+  %0 = load i32* %x.addr, align 4
+  %dec = add nsw i32 %0, -1
+  store i32 %dec, i32* %x.addr, align 4
+  %tobool = icmp ne i32 %0, 0
+  br i1 %tobool, label %while.body, label %while.end
+
+while.body:                                       ; preds = %while.cond
+  br label %while.cond
+
+while.end:                                        ; preds = %while.cond
+  ret i32 0
+}
+
+attributes #0 = { optnone noinline }
+
+; Function passes run at -O1 and higher.
+; OPT-O1-DAG: Skipping pass 'Aggressive Dead Code Elimination'
+; OPT-O1-DAG: Skipping pass 'Value Propagation'
+; OPT-O1-DAG: Skipping pass 'Dead Store Elimination'
+; OPT-O1-DAG: Skipping pass 'Early CSE'
+; OPT-O1-DAG: Skipping pass 'Jump Threading'
+; OPT-O1-DAG: Skipping pass 'MemCpy Optimization'
+; OPT-O1-DAG: Skipping pass 'Reassociate expressions'
+; OPT-O1-DAG: Skipping pass 'Sparse Conditional Constant Propagation'
+; OPT-O1-DAG: Skipping pass 'SROA'
+; OPT-O1-DAG: Skipping pass 'Simplify the CFG'
+; OPT-O1-DAG: Skipping pass 'Tail Call Elimination'
+; OPT-O1-DAG: Skipping pass 'Lower 'expect' Intrinsics'
+; OPT-O1-DAG: Skipping pass 'Combine redundant instructions'
+; OPT-O1-DAG: Skipping pass 'Loop Pass Manager'
+
+; Additional function passes run at -O2 and higher.
+; OPT-O2O3-DAG: Skipping pass 'SLP Vectorizer'
+; OPT-O2O3-DAG: Skipping pass 'Global Value Numbering'
+
+; Machine function passes.
+; LLC-DAG: Skipping pass 'Loop Pass Manager'
+; LLC-DAG: Skipping pass 'Tail Duplication'
+; LLC-DAG: Skipping pass 'Optimize machine instruction PHIs'
+; LLC-DAG: Skipping pass 'Remove dead machine instructions'
+; LLC-DAG: Skipping pass 'Machine Loop Invariant Code Motion'
+; LLC-DAG: Skipping pass 'Machine Common Subexpression Elimination'
+; LLC-DAG: Skipping pass 'Machine code sinking'
+; LLC-DAG: Skipping pass 'Peephole Optimizations'
+; LLC-DAG: Skipping pass 'Process Implicit Definitions'
+; LLC-DAG: Skipping pass 'Control Flow Optimizer'
+; LLC-DAG: Skipping pass 'Machine Copy Propagation Pass'