2008-08-18 02:44:35 +08:00
|
|
|
//===-- OcamlGCPrinter.cpp - Ocaml frametable emitter ---------------------===//
|
2008-01-07 10:31:11 +08:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2008-08-18 02:44:35 +08:00
|
|
|
// This file implements printing the assembly code for an Ocaml frametable.
|
2008-01-07 10:31:11 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
2009-01-16 14:53:46 +08:00
|
|
|
|
2008-08-17 20:56:54 +08:00
|
|
|
#include "llvm/CodeGen/GCs.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/SmallString.h"
|
2008-01-07 10:31:11 +08:00
|
|
|
#include "llvm/CodeGen/AsmPrinter.h"
|
2008-08-18 02:44:35 +08:00
|
|
|
#include "llvm/CodeGen/GCMetadataPrinter.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/DataLayout.h"
|
2014-01-08 05:19:40 +08:00
|
|
|
#include "llvm/IR/Mangler.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Module.h"
|
2009-08-23 04:48:53 +08:00
|
|
|
#include "llvm/MC/MCAsmInfo.h"
|
2010-04-04 15:39:04 +08:00
|
|
|
#include "llvm/MC/MCContext.h"
|
2010-03-14 15:36:49 +08:00
|
|
|
#include "llvm/MC/MCStreamer.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/MC/MCSymbol.h"
|
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
#include "llvm/Support/FormattedStream.h"
|
2009-07-28 11:13:23 +08:00
|
|
|
#include "llvm/Target/TargetLoweringObjectFile.h"
|
2008-01-07 10:31:11 +08:00
|
|
|
#include "llvm/Target/TargetMachine.h"
|
2014-08-05 05:25:23 +08:00
|
|
|
#include "llvm/Target/TargetSubtargetInfo.h"
|
2010-12-20 04:43:38 +08:00
|
|
|
#include <cctype>
|
2008-01-07 10:31:11 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
2009-10-25 14:33:48 +08:00
|
|
|
class OcamlGCMetadataPrinter : public GCMetadataPrinter {
|
2008-08-17 20:08:44 +08:00
|
|
|
public:
|
Remove the Module pointer from GCStrategy and GCMetadataPrinter
In the current implementation, GCStrategy is a part of the ownership structure for the gc metadata which describes a Module. It also contains a reference to the module in question. As a result, GCStrategy instances are essentially Module specific.
I plan to transition away from this design. Instead, a GCStrategy will be owned by the LLVMContext. It will be a lightweight policy object which contains no information about the Modules or Functions involved, but can be easily reached given a Function.
The first step in this transition is to remove the direct Module reference from GCStrategy. This also requires removing the single user of this reference, the GCMetadataPrinter hierarchy. In theory, this will allow the lifetime of the printers to be scoped to the LLVMContext as well, but in practice, I'm not actually changing that. (Yet?)
An alternate design would have been to move the direct Module reference into the GCMetadataPrinter and change the keying of the owning maps to explicitly key off both GCStrategy and Module. I'm open to doing it that way instead, but didn't see much value in preserving the per Module association for GCMetadataPrinters.
The next change in this sequence will be to start unwinding the intertwined ownership between GCStrategy, GCModuleInfo, and GCFunctionInfo.
Differential Revision: http://reviews.llvm.org/D6566
llvm-svn: 223859
2014-12-10 07:57:54 +08:00
|
|
|
void beginAssembly(Module &M, AsmPrinter &AP) override;
|
|
|
|
void finishAssembly(Module &M, AsmPrinter &AP) override;
|
2008-01-07 10:31:11 +08:00
|
|
|
};
|
2009-01-16 14:53:46 +08:00
|
|
|
|
2008-01-07 10:31:11 +08:00
|
|
|
}
|
|
|
|
|
2008-08-17 20:08:44 +08:00
|
|
|
static GCMetadataPrinterRegistry::Add<OcamlGCMetadataPrinter>
|
|
|
|
Y("ocaml", "ocaml 3.10-compatible collector");
|
|
|
|
|
2008-08-18 02:44:35 +08:00
|
|
|
void llvm::linkOcamlGCPrinter() { }
|
2008-01-07 10:31:11 +08:00
|
|
|
|
2010-04-04 15:39:04 +08:00
|
|
|
static void EmitCamlGlobal(const Module &M, AsmPrinter &AP, const char *Id) {
|
2008-01-07 10:31:11 +08:00
|
|
|
const std::string &MId = M.getModuleIdentifier();
|
2009-01-16 14:53:46 +08:00
|
|
|
|
2010-04-04 15:39:04 +08:00
|
|
|
std::string SymName;
|
|
|
|
SymName += "caml";
|
|
|
|
size_t Letter = SymName.size();
|
|
|
|
SymName.append(MId.begin(), std::find(MId.begin(), MId.end(), '.'));
|
|
|
|
SymName += "__";
|
|
|
|
SymName += Id;
|
2010-07-01 09:00:22 +08:00
|
|
|
|
2008-01-07 10:31:11 +08:00
|
|
|
// Capitalize the first letter of the module name.
|
2010-04-04 15:39:04 +08:00
|
|
|
SymName[Letter] = toupper(SymName[Letter]);
|
2010-07-01 09:00:22 +08:00
|
|
|
|
2010-04-04 15:39:04 +08:00
|
|
|
SmallString<128> TmpStr;
|
|
|
|
AP.Mang->getNameWithPrefix(TmpStr, SymName);
|
2010-07-01 09:00:22 +08:00
|
|
|
|
2010-04-04 15:39:04 +08:00
|
|
|
MCSymbol *Sym = AP.OutContext.GetOrCreateSymbol(TmpStr);
|
|
|
|
|
|
|
|
AP.OutStreamer.EmitSymbolAttribute(Sym, MCSA_Global);
|
|
|
|
AP.OutStreamer.EmitLabel(Sym);
|
2008-01-07 10:31:11 +08:00
|
|
|
}
|
|
|
|
|
Remove the Module pointer from GCStrategy and GCMetadataPrinter
In the current implementation, GCStrategy is a part of the ownership structure for the gc metadata which describes a Module. It also contains a reference to the module in question. As a result, GCStrategy instances are essentially Module specific.
I plan to transition away from this design. Instead, a GCStrategy will be owned by the LLVMContext. It will be a lightweight policy object which contains no information about the Modules or Functions involved, but can be easily reached given a Function.
The first step in this transition is to remove the direct Module reference from GCStrategy. This also requires removing the single user of this reference, the GCMetadataPrinter hierarchy. In theory, this will allow the lifetime of the printers to be scoped to the LLVMContext as well, but in practice, I'm not actually changing that. (Yet?)
An alternate design would have been to move the direct Module reference into the GCMetadataPrinter and change the keying of the owning maps to explicitly key off both GCStrategy and Module. I'm open to doing it that way instead, but didn't see much value in preserving the per Module association for GCMetadataPrinters.
The next change in this sequence will be to start unwinding the intertwined ownership between GCStrategy, GCModuleInfo, and GCFunctionInfo.
Differential Revision: http://reviews.llvm.org/D6566
llvm-svn: 223859
2014-12-10 07:57:54 +08:00
|
|
|
void OcamlGCMetadataPrinter::beginAssembly(Module &M, AsmPrinter &AP) {
|
2009-08-19 13:49:37 +08:00
|
|
|
AP.OutStreamer.SwitchSection(AP.getObjFileLowering().getTextSection());
|
Remove the Module pointer from GCStrategy and GCMetadataPrinter
In the current implementation, GCStrategy is a part of the ownership structure for the gc metadata which describes a Module. It also contains a reference to the module in question. As a result, GCStrategy instances are essentially Module specific.
I plan to transition away from this design. Instead, a GCStrategy will be owned by the LLVMContext. It will be a lightweight policy object which contains no information about the Modules or Functions involved, but can be easily reached given a Function.
The first step in this transition is to remove the direct Module reference from GCStrategy. This also requires removing the single user of this reference, the GCMetadataPrinter hierarchy. In theory, this will allow the lifetime of the printers to be scoped to the LLVMContext as well, but in practice, I'm not actually changing that. (Yet?)
An alternate design would have been to move the direct Module reference into the GCMetadataPrinter and change the keying of the owning maps to explicitly key off both GCStrategy and Module. I'm open to doing it that way instead, but didn't see much value in preserving the per Module association for GCMetadataPrinters.
The next change in this sequence will be to start unwinding the intertwined ownership between GCStrategy, GCModuleInfo, and GCFunctionInfo.
Differential Revision: http://reviews.llvm.org/D6566
llvm-svn: 223859
2014-12-10 07:57:54 +08:00
|
|
|
EmitCamlGlobal(M, AP, "code_begin");
|
2009-01-16 14:53:46 +08:00
|
|
|
|
2009-08-19 13:49:37 +08:00
|
|
|
AP.OutStreamer.SwitchSection(AP.getObjFileLowering().getDataSection());
|
Remove the Module pointer from GCStrategy and GCMetadataPrinter
In the current implementation, GCStrategy is a part of the ownership structure for the gc metadata which describes a Module. It also contains a reference to the module in question. As a result, GCStrategy instances are essentially Module specific.
I plan to transition away from this design. Instead, a GCStrategy will be owned by the LLVMContext. It will be a lightweight policy object which contains no information about the Modules or Functions involved, but can be easily reached given a Function.
The first step in this transition is to remove the direct Module reference from GCStrategy. This also requires removing the single user of this reference, the GCMetadataPrinter hierarchy. In theory, this will allow the lifetime of the printers to be scoped to the LLVMContext as well, but in practice, I'm not actually changing that. (Yet?)
An alternate design would have been to move the direct Module reference into the GCMetadataPrinter and change the keying of the owning maps to explicitly key off both GCStrategy and Module. I'm open to doing it that way instead, but didn't see much value in preserving the per Module association for GCMetadataPrinters.
The next change in this sequence will be to start unwinding the intertwined ownership between GCStrategy, GCModuleInfo, and GCFunctionInfo.
Differential Revision: http://reviews.llvm.org/D6566
llvm-svn: 223859
2014-12-10 07:57:54 +08:00
|
|
|
EmitCamlGlobal(M, AP, "data_begin");
|
2008-01-07 10:31:11 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// emitAssembly - Print the frametable. The ocaml frametable format is thus:
|
2009-01-16 14:53:46 +08:00
|
|
|
///
|
2008-01-07 10:31:11 +08:00
|
|
|
/// extern "C" struct align(sizeof(intptr_t)) {
|
|
|
|
/// uint16_t NumDescriptors;
|
|
|
|
/// struct align(sizeof(intptr_t)) {
|
|
|
|
/// void *ReturnAddress;
|
|
|
|
/// uint16_t FrameSize;
|
|
|
|
/// uint16_t NumLiveOffsets;
|
|
|
|
/// uint16_t LiveOffsets[NumLiveOffsets];
|
|
|
|
/// } Descriptors[NumDescriptors];
|
|
|
|
/// } caml${module}__frametable;
|
2009-01-16 14:53:46 +08:00
|
|
|
///
|
2008-01-07 10:31:11 +08:00
|
|
|
/// Note that this precludes programs from stack frames larger than 64K
|
|
|
|
/// (FrameSize and LiveOffsets would overflow). FrameTablePrinter will abort if
|
2008-08-18 02:44:35 +08:00
|
|
|
/// either condition is detected in a function which uses the GC.
|
2009-01-16 14:53:46 +08:00
|
|
|
///
|
Remove the Module pointer from GCStrategy and GCMetadataPrinter
In the current implementation, GCStrategy is a part of the ownership structure for the gc metadata which describes a Module. It also contains a reference to the module in question. As a result, GCStrategy instances are essentially Module specific.
I plan to transition away from this design. Instead, a GCStrategy will be owned by the LLVMContext. It will be a lightweight policy object which contains no information about the Modules or Functions involved, but can be easily reached given a Function.
The first step in this transition is to remove the direct Module reference from GCStrategy. This also requires removing the single user of this reference, the GCMetadataPrinter hierarchy. In theory, this will allow the lifetime of the printers to be scoped to the LLVMContext as well, but in practice, I'm not actually changing that. (Yet?)
An alternate design would have been to move the direct Module reference into the GCMetadataPrinter and change the keying of the owning maps to explicitly key off both GCStrategy and Module. I'm open to doing it that way instead, but didn't see much value in preserving the per Module association for GCMetadataPrinters.
The next change in this sequence will be to start unwinding the intertwined ownership between GCStrategy, GCModuleInfo, and GCFunctionInfo.
Differential Revision: http://reviews.llvm.org/D6566
llvm-svn: 223859
2014-12-10 07:57:54 +08:00
|
|
|
void OcamlGCMetadataPrinter::finishAssembly(Module &M, AsmPrinter &AP) {
|
2014-08-05 05:25:23 +08:00
|
|
|
unsigned IntPtrSize =
|
|
|
|
AP.TM.getSubtargetImpl()->getDataLayout()->getPointerSize();
|
2008-01-07 10:31:11 +08:00
|
|
|
|
2009-08-19 13:49:37 +08:00
|
|
|
AP.OutStreamer.SwitchSection(AP.getObjFileLowering().getTextSection());
|
Remove the Module pointer from GCStrategy and GCMetadataPrinter
In the current implementation, GCStrategy is a part of the ownership structure for the gc metadata which describes a Module. It also contains a reference to the module in question. As a result, GCStrategy instances are essentially Module specific.
I plan to transition away from this design. Instead, a GCStrategy will be owned by the LLVMContext. It will be a lightweight policy object which contains no information about the Modules or Functions involved, but can be easily reached given a Function.
The first step in this transition is to remove the direct Module reference from GCStrategy. This also requires removing the single user of this reference, the GCMetadataPrinter hierarchy. In theory, this will allow the lifetime of the printers to be scoped to the LLVMContext as well, but in practice, I'm not actually changing that. (Yet?)
An alternate design would have been to move the direct Module reference into the GCMetadataPrinter and change the keying of the owning maps to explicitly key off both GCStrategy and Module. I'm open to doing it that way instead, but didn't see much value in preserving the per Module association for GCMetadataPrinters.
The next change in this sequence will be to start unwinding the intertwined ownership between GCStrategy, GCModuleInfo, and GCFunctionInfo.
Differential Revision: http://reviews.llvm.org/D6566
llvm-svn: 223859
2014-12-10 07:57:54 +08:00
|
|
|
EmitCamlGlobal(M, AP, "code_end");
|
2009-01-16 14:53:46 +08:00
|
|
|
|
2009-08-19 13:49:37 +08:00
|
|
|
AP.OutStreamer.SwitchSection(AP.getObjFileLowering().getDataSection());
|
Remove the Module pointer from GCStrategy and GCMetadataPrinter
In the current implementation, GCStrategy is a part of the ownership structure for the gc metadata which describes a Module. It also contains a reference to the module in question. As a result, GCStrategy instances are essentially Module specific.
I plan to transition away from this design. Instead, a GCStrategy will be owned by the LLVMContext. It will be a lightweight policy object which contains no information about the Modules or Functions involved, but can be easily reached given a Function.
The first step in this transition is to remove the direct Module reference from GCStrategy. This also requires removing the single user of this reference, the GCMetadataPrinter hierarchy. In theory, this will allow the lifetime of the printers to be scoped to the LLVMContext as well, but in practice, I'm not actually changing that. (Yet?)
An alternate design would have been to move the direct Module reference into the GCMetadataPrinter and change the keying of the owning maps to explicitly key off both GCStrategy and Module. I'm open to doing it that way instead, but didn't see much value in preserving the per Module association for GCMetadataPrinters.
The next change in this sequence will be to start unwinding the intertwined ownership between GCStrategy, GCModuleInfo, and GCFunctionInfo.
Differential Revision: http://reviews.llvm.org/D6566
llvm-svn: 223859
2014-12-10 07:57:54 +08:00
|
|
|
EmitCamlGlobal(M, AP, "data_end");
|
2009-01-16 14:53:46 +08:00
|
|
|
|
2010-04-04 15:39:04 +08:00
|
|
|
// FIXME: Why does ocaml emit this??
|
2013-01-09 09:57:54 +08:00
|
|
|
AP.OutStreamer.EmitIntValue(0, IntPtrSize);
|
2009-01-16 14:53:46 +08:00
|
|
|
|
2009-08-19 13:49:37 +08:00
|
|
|
AP.OutStreamer.SwitchSection(AP.getObjFileLowering().getDataSection());
|
Remove the Module pointer from GCStrategy and GCMetadataPrinter
In the current implementation, GCStrategy is a part of the ownership structure for the gc metadata which describes a Module. It also contains a reference to the module in question. As a result, GCStrategy instances are essentially Module specific.
I plan to transition away from this design. Instead, a GCStrategy will be owned by the LLVMContext. It will be a lightweight policy object which contains no information about the Modules or Functions involved, but can be easily reached given a Function.
The first step in this transition is to remove the direct Module reference from GCStrategy. This also requires removing the single user of this reference, the GCMetadataPrinter hierarchy. In theory, this will allow the lifetime of the printers to be scoped to the LLVMContext as well, but in practice, I'm not actually changing that. (Yet?)
An alternate design would have been to move the direct Module reference into the GCMetadataPrinter and change the keying of the owning maps to explicitly key off both GCStrategy and Module. I'm open to doing it that way instead, but didn't see much value in preserving the per Module association for GCMetadataPrinters.
The next change in this sequence will be to start unwinding the intertwined ownership between GCStrategy, GCModuleInfo, and GCFunctionInfo.
Differential Revision: http://reviews.llvm.org/D6566
llvm-svn: 223859
2014-12-10 07:57:54 +08:00
|
|
|
EmitCamlGlobal(M, AP, "frametable");
|
2009-01-16 14:53:46 +08:00
|
|
|
|
2010-05-24 20:24:11 +08:00
|
|
|
int NumDescriptors = 0;
|
|
|
|
for (iterator I = begin(), IE = end(); I != IE; ++I) {
|
|
|
|
GCFunctionInfo &FI = **I;
|
|
|
|
for (GCFunctionInfo::iterator J = FI.begin(), JE = FI.end(); J != JE; ++J) {
|
|
|
|
NumDescriptors++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (NumDescriptors >= 1<<16) {
|
|
|
|
// Very rude!
|
|
|
|
report_fatal_error(" Too much descriptor for ocaml GC");
|
|
|
|
}
|
|
|
|
AP.EmitInt16(NumDescriptors);
|
|
|
|
AP.EmitAlignment(IntPtrSize == 4 ? 2 : 3);
|
|
|
|
|
2008-08-18 02:44:35 +08:00
|
|
|
for (iterator I = begin(), IE = end(); I != IE; ++I) {
|
|
|
|
GCFunctionInfo &FI = **I;
|
2009-01-16 14:53:46 +08:00
|
|
|
|
2008-08-18 02:44:35 +08:00
|
|
|
uint64_t FrameSize = FI.getFrameSize();
|
|
|
|
if (FrameSize >= 1<<16) {
|
2010-04-08 18:44:28 +08:00
|
|
|
// Very rude!
|
|
|
|
report_fatal_error("Function '" + FI.getFunction().getName() +
|
|
|
|
"' is too large for the ocaml GC! "
|
|
|
|
"Frame size " + Twine(FrameSize) + ">= 65536.\n"
|
|
|
|
"(" + Twine(uintptr_t(&FI)) + ")");
|
2008-08-18 02:44:35 +08:00
|
|
|
}
|
2009-01-16 14:53:46 +08:00
|
|
|
|
2010-04-04 15:39:04 +08:00
|
|
|
AP.OutStreamer.AddComment("live roots for " +
|
|
|
|
Twine(FI.getFunction().getName()));
|
|
|
|
AP.OutStreamer.AddBlankLine();
|
2009-01-16 14:53:46 +08:00
|
|
|
|
2008-08-18 02:44:35 +08:00
|
|
|
for (GCFunctionInfo::iterator J = FI.begin(), JE = FI.end(); J != JE; ++J) {
|
|
|
|
size_t LiveCount = FI.live_size(J);
|
2008-08-09 11:48:46 +08:00
|
|
|
if (LiveCount >= 1<<16) {
|
2010-04-08 18:44:28 +08:00
|
|
|
// Very rude!
|
|
|
|
report_fatal_error("Function '" + FI.getFunction().getName() +
|
|
|
|
"' is too large for the ocaml GC! "
|
|
|
|
"Live root count "+Twine(LiveCount)+" >= 65536.");
|
2008-01-07 10:31:11 +08:00
|
|
|
}
|
2009-01-16 14:53:46 +08:00
|
|
|
|
2013-01-09 11:52:05 +08:00
|
|
|
AP.OutStreamer.EmitSymbolValue(J->Label, IntPtrSize);
|
2008-01-07 10:31:11 +08:00
|
|
|
AP.EmitInt16(FrameSize);
|
|
|
|
AP.EmitInt16(LiveCount);
|
2009-01-16 14:53:46 +08:00
|
|
|
|
2008-08-18 02:44:35 +08:00
|
|
|
for (GCFunctionInfo::live_iterator K = FI.live_begin(J),
|
|
|
|
KE = FI.live_end(J); K != KE; ++K) {
|
2010-05-24 20:24:11 +08:00
|
|
|
if (K->StackOffset >= 1<<16) {
|
|
|
|
// Very rude!
|
|
|
|
report_fatal_error(
|
|
|
|
"GC root stack offset is outside of fixed stack frame and out "
|
|
|
|
"of range for ocaml GC!");
|
|
|
|
}
|
|
|
|
AP.EmitInt16(K->StackOffset);
|
2008-01-07 10:31:11 +08:00
|
|
|
}
|
2009-01-16 14:53:46 +08:00
|
|
|
|
2010-04-04 15:39:04 +08:00
|
|
|
AP.EmitAlignment(IntPtrSize == 4 ? 2 : 3);
|
2008-01-07 10:31:11 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|