6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-18 12:29:27 +00:00
Code Issues Projects Releases Wiki Activity

Switch over to a model where we compile each method, emit assembly, then free

Browse Source 
machineinstr memory before starting on the next method.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1659 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2002-02-03 07:54:10 +00:00
parent 71947fdbc6
commit c889677195
1 changed files with 35 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
tools/llc/llc.cpp
View File

@ -71,22 +71,42 @@ public:
//===---------------------------------------------------------------------===//
// EmitAssembly Pass
// EmitMethodAssembly Pass
//
// Write assembly code to specified output stream
// Write assembly code for each method to specified output stream
//===---------------------------------------------------------------------===//
class EmitAssembly : public Pass {
class EmitMethodAssembly : public MethodPass {
TargetMachine &Target; // Target to compile for
std::ostream *Out; // Stream to print on
public:
inline EmitMethodAssembly(TargetMachine &T, std::ostream *O)
: Target(T), Out(O) {}
virtual bool runOnMethod(Method *M) {
Target.emitAssembly(M, *Out);
Target.freeCompiledMethod(M); // Release memory for the method
return false;
}
};
//===---------------------------------------------------------------------===//
// EmitGlobalsAssembly Pass
//
// Write assembly code for global values to specified output stream
//===---------------------------------------------------------------------===//
class EmitGlobalsAssembly : public Pass {
const TargetMachine &Target; // Target to compile for
std::ostream *Out; // Stream to print on
bool DeleteStream; // Delete stream in dtor?
public:
inline EmitAssembly(const TargetMachine &T, std::ostream *O, bool D)
inline EmitGlobalsAssembly(const TargetMachine &T, std::ostream *O, bool D)
: Target(T), Out(O), DeleteStream(D) {}
virtual bool run(Module *M) {
Target.emitAssembly(M, *Out);
if (DeleteStream) delete Out;
return false;
}
@ -201,8 +221,16 @@ int main(int argc, char **argv) {
}
}
// Output assembly language to the .s file
Passes.add(new EmitAssembly(Target, Out, Out != &std::cout));
// Output assembly language to the .s file. Assembly emission is split into
// two parts: Method output and Global value output. This is because method
// output is pipelined with all of the rest of code generation stuff,
// allowing machine code representations for methods to be free'd after the
// method has been emitted.
//
Passes.add(new EmitMethodAssembly(Target, Out)); // for methods
// For global values...
Passes.add(new EmitGlobalsAssembly(Target, Out, Out != &std::cout));
}
// Run our queue of passes all at once now, efficiently.