From 9466f5113ba859677a28887c3c7143065e702019 Mon Sep 17 00:00:00 2001 From: "Vikram S. Adve" Date: Sun, 28 Oct 2001 21:38:02 +0000 Subject: [PATCH] Added name-mangling routines for future use. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1003 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Linker/LinkModules.cpp | 59 +++++++++++++++++++++++++++++++++ lib/Transforms/Utils/Linker.cpp | 59 +++++++++++++++++++++++++++++++++ lib/VMCore/Linker.cpp | 59 +++++++++++++++++++++++++++++++++ 3 files changed, 177 insertions(+) diff --git a/lib/Linker/LinkModules.cpp b/lib/Linker/LinkModules.cpp index 55023b82bf9..2be56989718 100644 --- a/lib/Linker/LinkModules.cpp +++ b/lib/Linker/LinkModules.cpp @@ -16,6 +16,8 @@ #include "llvm/SymbolTable.h" #include "llvm/DerivedTypes.h" #include "llvm/iOther.h" +#include "string" + // Error - Simple wrapper function to conditionally assign to E and return true. // This just makes error return conditions a little bit simpler... @@ -350,3 +352,60 @@ bool LinkModules(Module *Dest, const Module *Src, string *ErrorMsg = 0) { return false; } + + +// MangleTypeName - Implement a consistent name-mangling scheme for +// a given type. +// +string +MangleTypeName(const Type* type) +{ + string mangledName; + + if (type->isPrimitiveType()) + { + const string& longName = type->getDescription(); + mangledName = string(longName.c_str(), (longName.length() < 2)? 1 : 2); + } + else if (type->getPrimitiveID() == Type::PointerTyID) + { + PointerType* ptype = (PointerType*) type; + mangledName = string("P_" + MangleTypeName(ptype->getValueType())); + } + else if (type->getPrimitiveID() == Type::StructTyID) + { + StructType* stype = (StructType*) type; + mangledName = string("S_"); + for (unsigned i=0; i < stype->getNumContainedTypes(); ++i) + mangledName += string(MangleTypeName(stype->getContainedType(i))); + } + else if (type->getPrimitiveID() == Type::ArrayTyID) + { + ArrayType* atype = (ArrayType*) type; + mangledName = string("A_" +MangleTypeName(atype->getElementType())); + } + else if (type->getPrimitiveID() == Type::MethodTyID) + { + MethodType* mtype = (MethodType*) type; + mangledName = string("M_") + MangleTypeName(mtype->getReturnType()); + for (unsigned i=1; i < mtype->getNumContainedTypes(); ++i) + mangledName += string(MangleTypeName(mtype->getContainedType(i))); + } + + return mangledName; +} + + +// mangleName - implement a consistent name-mangling scheme for all +// externally visible (i.e., global) objects. +// privateName should be unique within the module. +// +string +MangleName(const string& privateName, const Value* V) +{ + // Lets drop the P_ before every global name since all globals are ptrs + return privateName + "_" + + MangleTypeName((isa(V) + ? cast(V)->getType()->getValueType() + : V->getType())); +} diff --git a/lib/Transforms/Utils/Linker.cpp b/lib/Transforms/Utils/Linker.cpp index 55023b82bf9..2be56989718 100644 --- a/lib/Transforms/Utils/Linker.cpp +++ b/lib/Transforms/Utils/Linker.cpp @@ -16,6 +16,8 @@ #include "llvm/SymbolTable.h" #include "llvm/DerivedTypes.h" #include "llvm/iOther.h" +#include "string" + // Error - Simple wrapper function to conditionally assign to E and return true. // This just makes error return conditions a little bit simpler... @@ -350,3 +352,60 @@ bool LinkModules(Module *Dest, const Module *Src, string *ErrorMsg = 0) { return false; } + + +// MangleTypeName - Implement a consistent name-mangling scheme for +// a given type. +// +string +MangleTypeName(const Type* type) +{ + string mangledName; + + if (type->isPrimitiveType()) + { + const string& longName = type->getDescription(); + mangledName = string(longName.c_str(), (longName.length() < 2)? 1 : 2); + } + else if (type->getPrimitiveID() == Type::PointerTyID) + { + PointerType* ptype = (PointerType*) type; + mangledName = string("P_" + MangleTypeName(ptype->getValueType())); + } + else if (type->getPrimitiveID() == Type::StructTyID) + { + StructType* stype = (StructType*) type; + mangledName = string("S_"); + for (unsigned i=0; i < stype->getNumContainedTypes(); ++i) + mangledName += string(MangleTypeName(stype->getContainedType(i))); + } + else if (type->getPrimitiveID() == Type::ArrayTyID) + { + ArrayType* atype = (ArrayType*) type; + mangledName = string("A_" +MangleTypeName(atype->getElementType())); + } + else if (type->getPrimitiveID() == Type::MethodTyID) + { + MethodType* mtype = (MethodType*) type; + mangledName = string("M_") + MangleTypeName(mtype->getReturnType()); + for (unsigned i=1; i < mtype->getNumContainedTypes(); ++i) + mangledName += string(MangleTypeName(mtype->getContainedType(i))); + } + + return mangledName; +} + + +// mangleName - implement a consistent name-mangling scheme for all +// externally visible (i.e., global) objects. +// privateName should be unique within the module. +// +string +MangleName(const string& privateName, const Value* V) +{ + // Lets drop the P_ before every global name since all globals are ptrs + return privateName + "_" + + MangleTypeName((isa(V) + ? cast(V)->getType()->getValueType() + : V->getType())); +} diff --git a/lib/VMCore/Linker.cpp b/lib/VMCore/Linker.cpp index 55023b82bf9..2be56989718 100644 --- a/lib/VMCore/Linker.cpp +++ b/lib/VMCore/Linker.cpp @@ -16,6 +16,8 @@ #include "llvm/SymbolTable.h" #include "llvm/DerivedTypes.h" #include "llvm/iOther.h" +#include "string" + // Error - Simple wrapper function to conditionally assign to E and return true. // This just makes error return conditions a little bit simpler... @@ -350,3 +352,60 @@ bool LinkModules(Module *Dest, const Module *Src, string *ErrorMsg = 0) { return false; } + + +// MangleTypeName - Implement a consistent name-mangling scheme for +// a given type. +// +string +MangleTypeName(const Type* type) +{ + string mangledName; + + if (type->isPrimitiveType()) + { + const string& longName = type->getDescription(); + mangledName = string(longName.c_str(), (longName.length() < 2)? 1 : 2); + } + else if (type->getPrimitiveID() == Type::PointerTyID) + { + PointerType* ptype = (PointerType*) type; + mangledName = string("P_" + MangleTypeName(ptype->getValueType())); + } + else if (type->getPrimitiveID() == Type::StructTyID) + { + StructType* stype = (StructType*) type; + mangledName = string("S_"); + for (unsigned i=0; i < stype->getNumContainedTypes(); ++i) + mangledName += string(MangleTypeName(stype->getContainedType(i))); + } + else if (type->getPrimitiveID() == Type::ArrayTyID) + { + ArrayType* atype = (ArrayType*) type; + mangledName = string("A_" +MangleTypeName(atype->getElementType())); + } + else if (type->getPrimitiveID() == Type::MethodTyID) + { + MethodType* mtype = (MethodType*) type; + mangledName = string("M_") + MangleTypeName(mtype->getReturnType()); + for (unsigned i=1; i < mtype->getNumContainedTypes(); ++i) + mangledName += string(MangleTypeName(mtype->getContainedType(i))); + } + + return mangledName; +} + + +// mangleName - implement a consistent name-mangling scheme for all +// externally visible (i.e., global) objects. +// privateName should be unique within the module. +// +string +MangleName(const string& privateName, const Value* V) +{ + // Lets drop the P_ before every global name since all globals are ptrs + return privateName + "_" + + MangleTypeName((isa(V) + ? cast(V)->getType()->getValueType() + : V->getType())); +}