Google Git
Sign in
llvm / llvm-archive / 089ca8750d7cd1f1ec96968922bf4bcfe223bb3a / . / hlvm / hlvm / CodeGen / LLVMEmitter.cpp
blob: 1cfc91a8c6a3a3c223ce76f41662b1ad3def5227 [file] [log] [blame]
//===-- LLVM Code Emitter Implementation ------------------------*- C++ -*-===//
//
// High Level Virtual Machine (HLVM)
//
// Copyright (C) 2006 Reid Spencer. All Rights Reserved.
//
// This software is free software; you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation; either version 2.1 of the License, or (at
// your option) any later version.
//
// This software is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
// more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library in the file named LICENSE.txt; if not, write to the
// Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
// MA 02110-1301 USA
//
//===----------------------------------------------------------------------===//
/// @file hlvm/CodeGen/LLVMEmitter.cpp
/// @author Reid Spencer <rspencer@x10sys.com>
/// @date 2006/07/08
/// @since 0.2.0
/// @brief Provides the implementation of the LLVM Code Emitter
//===----------------------------------------------------------------------===//
#include <hlvm/CodeGen/LLVMEmitter.h>
#include <hlvm/Base/Assert.h>
using namespace llvm;
namespace {
class LLVMEmitterImpl : public hlvm::LLVMEmitter
{
/// @name Data
/// @{
private:
// Caches of things to interface with the HLVM Runtime Library
PointerType* hlvm_text; ///< Opaque type for text objects
Function* hlvm_text_create; ///< Create a new text object
Function* hlvm_text_delete; ///< Delete a text object
Function* hlvm_text_to_buffer;///< Convert text to a buffer
PointerType* hlvm_buffer; ///< Pointer To octet
Function* hlvm_buffer_create; ///< Create a new buffer object
Function* hlvm_buffer_delete; ///< Delete a buffer
PointerType* hlvm_stream; ///< Pointer to stream type
Function* hlvm_stream_open; ///< Function for stream_open
Function* hlvm_stream_read; ///< Function for stream_read
Function* hlvm_stream_write_buffer; ///< Write buffer to stream
Function* hlvm_stream_write_text; ///< Write text to stream
Function* hlvm_stream_write_string; ///< Write string to stream
Function* hlvm_stream_close; ///< Function for stream_close
Function* hlvm_f32_ispinf;
Function* hlvm_f32_isninf ;
Function* hlvm_f32_isnan ;
Function* hlvm_f32_trunc ;
Function* hlvm_f32_round ;
Function* hlvm_f32_floor ;
Function* hlvm_f32_ceiling ;
Function* hlvm_f32_loge ;
Function* hlvm_f32_log2 ;
Function* hlvm_f32_log10 ;
Function* hlvm_f32_squareroot ;
Function* hlvm_f32_cuberoot ;
Function* hlvm_f32_factorial ;
Function* hlvm_f32_power ;
Function* hlvm_f32_root ;
Function* hlvm_f32_gcd ;
Function* hlvm_f32_lcm;
Function* hlvm_f64_ispinf;
Function* hlvm_f64_isninf ;
Function* hlvm_f64_isnan ;
Function* hlvm_f64_trunc ;
Function* hlvm_f64_round ;
Function* hlvm_f64_floor ;
Function* hlvm_f64_ceiling ;
Function* hlvm_f64_loge ;
Function* hlvm_f64_log2 ;
Function* hlvm_f64_log10 ;
Function* hlvm_f64_squareroot ;
Function* hlvm_f64_cuberoot ;
Function* hlvm_f64_factorial ;
Function* hlvm_f64_power ;
Function* hlvm_f64_root ;
Function* hlvm_f64_gcd ;
Function* hlvm_f64_lcm;
FunctionType* hlvm_program_signature; ///< The llvm type for programs
// Caches of LLVM Intrinsic functions
Function* llvm_memcpy; ///< llvm.memcpy.i64
Function* llvm_memmove; ///< llvm.memmove.i64
Function* llvm_memset; ///< llvm.memset.i64
/// @}
/// @name Constructor
/// @{
public:
LLVMEmitterImpl() : hlvm::LLVMEmitter(),
hlvm_text(0), hlvm_text_create(0), hlvm_text_delete(0),
hlvm_text_to_buffer(0),
hlvm_buffer(0), hlvm_buffer_create(0), hlvm_buffer_delete(0),
hlvm_stream(0), hlvm_stream_open(0), hlvm_stream_read(0),
hlvm_stream_write_buffer(0), hlvm_stream_write_text(0),
hlvm_stream_write_string(0), hlvm_stream_close(0),
hlvm_f32_ispinf(0), hlvm_f32_isninf(0), hlvm_f32_isnan(0),
hlvm_f32_trunc(0), hlvm_f32_round(0), hlvm_f32_floor (0),
hlvm_f32_ceiling(0), hlvm_f32_loge(0), hlvm_f32_log2(0),
hlvm_f32_log10(0), hlvm_f32_squareroot(0), hlvm_f32_cuberoot(0),
hlvm_f32_factorial(0), hlvm_f32_power(0), hlvm_f32_root(0),
hlvm_f32_gcd(0), hlvm_f32_lcm(0), hlvm_f64_ispinf(0), hlvm_f64_isninf(0),
hlvm_f64_isnan(0), hlvm_f64_trunc(0), hlvm_f64_round(0),
hlvm_f64_floor(0), hlvm_f64_ceiling(0), hlvm_f64_loge(0),
hlvm_f64_log2(0), hlvm_f64_log10(0), hlvm_f64_squareroot(0),
hlvm_f64_cuberoot(0), hlvm_f64_factorial(0), hlvm_f64_power(0),
hlvm_f64_root(0), hlvm_f64_gcd(0), hlvm_f64_lcm(0),
hlvm_program_signature(0),
llvm_memcpy(0), llvm_memmove(0), llvm_memset(0)
{
}
/// @}
/// @name Methods
/// @{
public:
const Type* get_hlvm_size() { return Type::Int64Ty; }
PointerType* get_hlvm_text()
{
if (! hlvm_text) {
// An hlvm_text is a variable length array of signed bytes preceded by
// an
// Arglist args;
// args.push_back(Type::Int32Ty);
// args.push_back(ArrayType::Get(Type::Int8Ty,0));
OpaqueType* opq = OpaqueType::get();
TheModule->addTypeName("hlvm_text_obj", opq);
hlvm_text = PointerType::get(opq);
TheModule->addTypeName("hlvm_text", hlvm_text);
}
return hlvm_text;
}
Function* get_hlvm_text_create()
{
if (! hlvm_text_create) {
Type* result = get_hlvm_text();
std::vector<const Type*> arg_types;
arg_types.push_back(PointerType::get(Type::Int8Ty));
FunctionType* FT =
FunctionType::get(result,arg_types,false);
TheModule->addTypeName("hlvm_text_create",FT);
hlvm_text_create =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_text_create", TheModule);
}
return hlvm_text_create;
}
CallInst* call_hlvm_text_create(const hlvm::ArgList& args, const char* nm)
{
Function* F = get_hlvm_text_create();
return new CallInst(F, args.begin(), args.end(), (nm ? nm : "buffer"),
TheBlock);
}
Function* get_hlvm_text_delete()
{
if (! hlvm_text_delete) {
Type* result = get_hlvm_text();
std::vector<const Type*> arg_types;
arg_types.push_back(get_hlvm_text());
FunctionType* FT =
FunctionType::get(result,arg_types,false);
TheModule->addTypeName("hlvm_text_delete",FT);
hlvm_text_delete =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_text_delete", TheModule);
}
return hlvm_text_delete;
}
CallInst* call_hlvm_text_delete(const hlvm::ArgList& args)
{
Function* F = get_hlvm_text_delete();
return new CallInst(F, args.begin(), args.end(), "hlvm_text_delete",
TheBlock);
}
Function* get_hlvm_text_to_buffer()
{
if (! hlvm_text_to_buffer) {
Type* result = get_hlvm_buffer();
std::vector<const Type*> arg_types;
arg_types.push_back(get_hlvm_text());
FunctionType* FT = FunctionType::get(result,arg_types,false);
TheModule->addTypeName("hlvm_text_to_buffer_signature",FT);
hlvm_text_to_buffer =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_text_to_buffer", TheModule);
}
return hlvm_text_to_buffer;
}
CallInst* call_hlvm_text_to_buffer(const hlvm::ArgList& args, const char* nm)
{
Function* F = get_hlvm_text_to_buffer();
return new CallInst(F, args.begin(), args.end(), (nm ? nm : "buffer"),
TheBlock);
}
PointerType* get_hlvm_buffer()
{
if (! hlvm_buffer) {
OpaqueType* opq = OpaqueType::get();
TheModule->addTypeName("hlvm_buffer_obj", opq);
hlvm_buffer = PointerType::get(opq);
TheModule->addTypeName("hlvm_buffer", hlvm_buffer);
}
return hlvm_buffer;
}
Function* get_hlvm_buffer_create()
{
if (! hlvm_buffer_create) {
Type* result = get_hlvm_buffer();
std::vector<const Type*> arg_types;
arg_types.push_back(get_hlvm_size());
FunctionType* FT = FunctionType::get(result,arg_types,false);
TheModule->addTypeName("hlvm_buffer_create",FT);
hlvm_buffer_create =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_buffer_create", TheModule);
}
return hlvm_buffer_create;
}
CallInst* call_hlvm_buffer_create(const hlvm::ArgList& args, const char* nm)
{
Function* F = get_hlvm_buffer_create();
return new CallInst(F, args.begin(), args.end(), (nm ? nm : "buffer"),
TheBlock);
}
Function* get_hlvm_buffer_delete()
{
if (! hlvm_buffer_delete) {
Type* result = get_hlvm_buffer();
std::vector<const Type*> arg_types;
arg_types.push_back(get_hlvm_buffer());
FunctionType* FT = FunctionType::get(result,arg_types,false);
TheModule->addTypeName("hlvm_buffer_delete",FT);
hlvm_buffer_delete =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_buffer_delete", TheModule);
}
return hlvm_buffer_delete;
}
CallInst* call_hlvm_buffer_delete(const hlvm::ArgList& args)
{
Function* F = get_hlvm_buffer_delete();
return new CallInst(F, args.begin(), args.end(), "", TheBlock);
}
PointerType* get_hlvm_stream()
{
if (! hlvm_stream) {
OpaqueType* opq = OpaqueType::get();
TheModule->addTypeName("hlvm_stream_obj", opq);
hlvm_stream = PointerType::get(opq);
TheModule->addTypeName("hlvm_stream", hlvm_stream);
}
return hlvm_stream;
}
Function* get_hlvm_stream_open()
{
if (!hlvm_stream_open) {
Type* result = get_hlvm_stream();
std::vector<const Type*> arg_types;
arg_types.push_back(PointerType::get(Type::Int8Ty));
FunctionType* FT = FunctionType::get(result,arg_types,false);
TheModule->addTypeName("hlvm_stream_open_signature",FT);
hlvm_stream_open =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_stream_open", TheModule);
}
return hlvm_stream_open;
}
CallInst* call_hlvm_stream_open(const hlvm::ArgList& args, const char* nm)
{
Function* F = get_hlvm_stream_open();
return new CallInst(F, args.begin(), args.end(), (nm ? nm : "stream"),
TheBlock);
}
Function* get_hlvm_stream_read()
{
if (!hlvm_stream_read) {
const Type* result = get_hlvm_size();
std::vector<const Type*> arg_types;
arg_types.push_back(get_hlvm_stream());
arg_types.push_back(get_hlvm_buffer());
arg_types.push_back(get_hlvm_size());
FunctionType* FT = FunctionType::get(result,arg_types,false);
TheModule->addTypeName("hlvm_stream_read_signature",FT);
hlvm_stream_read =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_stream_read", TheModule);
}
return hlvm_stream_read;
}
CallInst* call_hlvm_stream_read(const hlvm::ArgList& args, const char* nm)
{
Function* F = get_hlvm_stream_read();
return new CallInst(F, args.begin(), args.end(), (nm ? nm : "readlen"),
TheBlock);
}
Function* get_hlvm_stream_write_buffer()
{
if (!hlvm_stream_write_buffer) {
const Type* result = get_hlvm_size();
std::vector<const Type*> arg_types;
arg_types.push_back(get_hlvm_stream());
arg_types.push_back(get_hlvm_buffer());
FunctionType* FT = FunctionType::get(result,arg_types,false);
TheModule->addTypeName("hlvm_stream_write_buffer_signature",FT);
hlvm_stream_write_buffer =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_stream_write_buffer", TheModule);
}
return hlvm_stream_write_buffer;
}
CallInst* call_hlvm_stream_write_buffer(const hlvm::ArgList& args, const char* nm)
{
Function* F = get_hlvm_stream_write_buffer();
return new CallInst(F, args.begin(), args.end(), (nm ? nm : "writelen"),
TheBlock);
}
Function* get_hlvm_stream_write_string()
{
if (!hlvm_stream_write_string) {
const Type* result = get_hlvm_size();
std::vector<const Type*> arg_types;
arg_types.push_back(get_hlvm_stream());
arg_types.push_back(PointerType::get(Type::Int8Ty));
FunctionType* FT = FunctionType::get(result,arg_types,false);
TheModule->addTypeName("hlvm_stream_write_string_signature",FT);
hlvm_stream_write_string =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_stream_write_string", TheModule);
}
return hlvm_stream_write_string;
}
CallInst* call_hlvm_stream_write_string(const hlvm::ArgList& args, const char* nm)
{
Function* F = get_hlvm_stream_write_string();
return new CallInst(F, args.begin(), args.end(), (nm ? nm : "writelen"),
TheBlock);
}
Function* get_hlvm_stream_write_text()
{
if (!hlvm_stream_write_text) {
const Type* result = get_hlvm_size();
std::vector<const Type*> arg_types;
arg_types.push_back(get_hlvm_stream());
arg_types.push_back(get_hlvm_text());
FunctionType* FT = FunctionType::get(result,arg_types,false);
TheModule->addTypeName("hlvm_stream_write_text_signature",FT);
hlvm_stream_write_text =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_stream_write_text", TheModule);
}
return hlvm_stream_write_text;
}
CallInst* call_hlvm_stream_write_text(const hlvm::ArgList& args, const char* nm)
{
Function* F = get_hlvm_stream_write_text();
return new CallInst(F, args.begin(), args.end(), (nm ? nm : "writelen"),
TheBlock);
}
Function* get_hlvm_stream_close()
{
if (!hlvm_stream_close) {
const Type* result = Type::VoidTy;
std::vector<const Type*> arg_types;
arg_types.push_back(get_hlvm_stream());
FunctionType* FT = FunctionType::get(result,arg_types,false);
TheModule->addTypeName("hlvm_stream_close_signature",FT);
hlvm_stream_close =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_stream_close", TheModule);
}
return hlvm_stream_close;
}
CallInst* call_hlvm_stream_close(const hlvm::ArgList& args)
{
Function* F = get_hlvm_stream_close();
return new CallInst(F, args.begin(), args.end(), "", TheBlock);
}
FunctionType* get_hlvm_program_signature()
{
if (!hlvm_program_signature) {
// Get the type of function that all entry points must have
std::vector<const Type*> arg_types;
arg_types.push_back(Type::Int32Ty);
arg_types.push_back(
PointerType::get(PointerType::get(Type::Int8Ty)));
hlvm_program_signature =
FunctionType::get(Type::Int32Ty,arg_types,false);
TheModule->addTypeName("hlvm_program_signature",hlvm_program_signature);
}
return hlvm_program_signature;
}
Function* get_llvm_memcpy()
{
if (!llvm_memcpy) {
const Type *SBP = PointerType::get(Type::Int8Ty);
llvm_memcpy = cast<Function>(TheModule->getOrInsertFunction(
"llvm.memcpy.i64", Type::VoidTy, SBP, SBP, Type::Int64Ty,
Type::Int32Ty, NULL));
}
return llvm_memcpy;
}
Function* get_llvm_memmove()
{
if (!llvm_memmove) {
const Type *SBP = PointerType::get(Type::Int8Ty);
llvm_memmove = cast<Function>(TheModule->getOrInsertFunction(
"llvm.memmove.i64", Type::VoidTy, SBP, SBP, Type::Int64Ty,
Type::Int32Ty, NULL));
}
return llvm_memmove;
}
Function* get_llvm_memset()
{
if (!llvm_memset) {
const Type *SBP = PointerType::get(Type::Int8Ty);
llvm_memset = cast<Function>(TheModule->getOrInsertFunction(
"llvm.memset.i64", Type::VoidTy, SBP, Type::Int8Ty, Type::Int64Ty,
Type::Int32Ty, NULL));
}
return llvm_memset;
}
Function* get_hlvm_f32_ispinf()
{
if (! hlvm_f32_ispinf) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::FloatTy);
FunctionType* FT = FunctionType::get(Type::FloatTy,arg_types,false);
TheModule->addTypeName("hlvm_f32_ispinf",FT);
hlvm_f32_ispinf =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f32_ispinf", TheModule);
}
return hlvm_f32_ispinf;
}
Function* get_hlvm_f32_isninf()
{
if (! hlvm_f32_isninf) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::FloatTy);
FunctionType* FT = FunctionType::get(Type::FloatTy,arg_types,false);
TheModule->addTypeName("hlvm_f32_isninf",FT);
hlvm_f32_isninf =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f32_isninf", TheModule);
}
return hlvm_f32_isninf;
}
Function* get_hlvm_f32_isnan()
{
if (! hlvm_f32_isnan) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::FloatTy);
FunctionType* FT = FunctionType::get(Type::FloatTy,arg_types,false);
TheModule->addTypeName("hlvm_f32_isnan",FT);
hlvm_f32_isnan =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f32_isnan", TheModule);
}
return hlvm_f32_isnan;
}
Function* get_hlvm_f32_trunc()
{
if (! hlvm_f32_trunc) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::FloatTy);
FunctionType* FT = FunctionType::get(Type::FloatTy,arg_types,false);
TheModule->addTypeName("hlvm_f32_trunc",FT);
hlvm_f32_trunc =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f32_trunc", TheModule);
}
return hlvm_f32_trunc;
}
Function* get_hlvm_f32_round()
{
if (! hlvm_f32_round) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::FloatTy);
FunctionType* FT = FunctionType::get(Type::FloatTy,arg_types,false);
TheModule->addTypeName("hlvm_f32_round",FT);
hlvm_f32_round =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f32_round", TheModule);
}
return hlvm_f32_round;
}
Function* get_hlvm_f32_floor()
{
if (! hlvm_f32_floor) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::FloatTy);
FunctionType* FT = FunctionType::get(Type::FloatTy,arg_types,false);
TheModule->addTypeName("hlvm_f32_floor",FT);
hlvm_f32_floor =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f32_floor", TheModule);
}
return hlvm_f32_floor;
}
Function* get_hlvm_f32_ceiling()
{
if (! hlvm_f32_ceiling) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::FloatTy);
FunctionType* FT = FunctionType::get(Type::FloatTy,arg_types,false);
TheModule->addTypeName("hlvm_f32_ceiling",FT);
hlvm_f32_ceiling =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f32_ceiling", TheModule);
}
return hlvm_f32_ceiling;
}
Function* get_hlvm_f32_loge()
{
if (! hlvm_f32_loge) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::FloatTy);
FunctionType* FT = FunctionType::get(Type::FloatTy,arg_types,false);
TheModule->addTypeName("hlvm_f32_loge",FT);
hlvm_f32_loge =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f32_loge", TheModule);
}
return hlvm_f32_loge;
}
Function* get_hlvm_f32_log2()
{
if (! hlvm_f32_log2) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::FloatTy);
FunctionType* FT = FunctionType::get(Type::FloatTy,arg_types,false);
TheModule->addTypeName("hlvm_f32_log2",FT);
hlvm_f32_log2 =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f32_log2", TheModule);
}
return hlvm_f32_log2;
}
Function* get_hlvm_f32_log10()
{
if (! hlvm_f32_log10) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::FloatTy);
FunctionType* FT = FunctionType::get(Type::FloatTy,arg_types,false);
TheModule->addTypeName("hlvm_f32_log10",FT);
hlvm_f32_log10 =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f32_log10", TheModule);
}
return hlvm_f32_log10;
}
Function* get_hlvm_f32_squareroot()
{
if (! hlvm_f32_squareroot) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::FloatTy);
FunctionType* FT = FunctionType::get(Type::FloatTy,arg_types,false);
TheModule->addTypeName("hlvm_f32_squareroot",FT);
hlvm_f32_squareroot =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f32_squareroot", TheModule);
}
return hlvm_f32_squareroot;
}
Function* get_hlvm_f32_cuberoot()
{
if (! hlvm_f32_cuberoot) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::FloatTy);
FunctionType* FT = FunctionType::get(Type::FloatTy,arg_types,false);
TheModule->addTypeName("hlvm_f32_cuberoot",FT);
hlvm_f32_cuberoot =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f32_cuberoot", TheModule);
}
return hlvm_f32_cuberoot;
}
Function* get_hlvm_f32_factorial()
{
if (! hlvm_f32_factorial) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::FloatTy);
FunctionType* FT = FunctionType::get(Type::FloatTy,arg_types,false);
TheModule->addTypeName("hlvm_f32_factorial",FT);
hlvm_f32_factorial =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f32_factorial", TheModule);
}
return hlvm_f32_factorial;
}
Function* get_hlvm_f32_power()
{
if (! hlvm_f32_power) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::FloatTy);
arg_types.push_back(Type::FloatTy);
FunctionType* FT = FunctionType::get(Type::FloatTy,arg_types,false);
TheModule->addTypeName("hlvm_f32_power",FT);
hlvm_f32_power =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f32_power", TheModule);
}
return hlvm_f32_ispinf;
}
Function* get_hlvm_f32_root()
{
if (! hlvm_f32_root) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::FloatTy);
arg_types.push_back(Type::FloatTy);
FunctionType* FT = FunctionType::get(Type::FloatTy,arg_types,false);
TheModule->addTypeName("hlvm_f32_root",FT);
hlvm_f32_root =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f32_root", TheModule);
}
return hlvm_f32_ispinf;
}
Function* get_hlvm_f32_gcd()
{
if (! hlvm_f32_gcd) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::FloatTy);
arg_types.push_back(Type::FloatTy);
FunctionType* FT = FunctionType::get(Type::FloatTy,arg_types,false);
TheModule->addTypeName("hlvm_f32_gcd",FT);
hlvm_f32_gcd =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f32_gcd", TheModule);
}
return hlvm_f32_ispinf;
}
Function* get_hlvm_f32_lcm()
{
if (! hlvm_f32_lcm) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::FloatTy);
arg_types.push_back(Type::FloatTy);
FunctionType* FT = FunctionType::get(Type::FloatTy,arg_types,false);
TheModule->addTypeName("hlvm_f32_lcm",FT);
hlvm_f32_lcm =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f32_lcm", TheModule);
}
return hlvm_f32_ispinf;
}
CallInst* call_hlvm_f32_ispinf(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f32_ispinf(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f32_isninf(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f32_isninf(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f32_isnan(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f32_isnan(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f32_trunc(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f32_trunc(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f32_round(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f32_round(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f32_floor(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f32_floor(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f32_ceiling(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f32_ceiling(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f32_loge(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f32_loge(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f32_log2(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f32_log2(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f32_log10(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f32_log10(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f32_squareroot(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f32_squareroot(), args.begin(), args.end(),
"", TheBlock);
}
CallInst* call_hlvm_f32_cuberoot(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f32_cuberoot(), args.begin(), args.end(),
"", TheBlock);
}
CallInst* call_hlvm_f32_factorial(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f32_factorial(), args.begin(), args.end(),
"", TheBlock);
}
CallInst* call_hlvm_f32_power(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f32_power(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f32_root(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f32_root(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f32_gcd(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f32_gcd(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f32_lcm(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f32_lcm(), args.begin(), args.end(), "",
TheBlock);
}
Function* get_hlvm_f64_ispinf()
{
if (! hlvm_f64_ispinf) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::DoubleTy);
FunctionType* FT = FunctionType::get(Type::DoubleTy,arg_types,false);
TheModule->addTypeName("hlvm_f64_ispinf",FT);
hlvm_f64_ispinf =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f64_ispinf", TheModule);
}
return hlvm_f64_ispinf;
}
Function* get_hlvm_f64_isninf()
{
if (! hlvm_f64_isninf) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::DoubleTy);
FunctionType* FT = FunctionType::get(Type::DoubleTy,arg_types,false);
TheModule->addTypeName("hlvm_f64_isninf",FT);
hlvm_f64_isninf =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f64_isninf", TheModule);
}
return hlvm_f64_isninf;
}
Function* get_hlvm_f64_isnan()
{
if (! hlvm_f64_isnan) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::DoubleTy);
FunctionType* FT = FunctionType::get(Type::DoubleTy,arg_types,false);
TheModule->addTypeName("hlvm_f64_isnan",FT);
hlvm_f64_isnan =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f64_isnan", TheModule);
}
return hlvm_f64_isnan;
}
Function* get_hlvm_f64_trunc()
{
if (! hlvm_f64_trunc) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::DoubleTy);
FunctionType* FT = FunctionType::get(Type::DoubleTy,arg_types,false);
TheModule->addTypeName("hlvm_f64_trunc",FT);
hlvm_f64_trunc =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f64_trunc", TheModule);
}
return hlvm_f64_trunc;
}
Function* get_hlvm_f64_round()
{
if (! hlvm_f64_round) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::DoubleTy);
FunctionType* FT = FunctionType::get(Type::DoubleTy,arg_types,false);
TheModule->addTypeName("hlvm_f64_round",FT);
hlvm_f64_round =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f64_round", TheModule);
}
return hlvm_f64_round;
}
Function* get_hlvm_f64_floor()
{
if (! hlvm_f64_floor) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::DoubleTy);
FunctionType* FT = FunctionType::get(Type::DoubleTy,arg_types,false);
TheModule->addTypeName("hlvm_f64_floor",FT);
hlvm_f64_floor =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f64_floor", TheModule);
}
return hlvm_f64_floor;
}
Function* get_hlvm_f64_ceiling()
{
if (! hlvm_f64_ceiling) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::DoubleTy);
FunctionType* FT = FunctionType::get(Type::DoubleTy,arg_types,false);
TheModule->addTypeName("hlvm_f64_ceiling",FT);
hlvm_f64_ceiling =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f64_ceiling", TheModule);
}
return hlvm_f64_ceiling;
}
Function* get_hlvm_f64_loge()
{
if (! hlvm_f64_loge) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::DoubleTy);
FunctionType* FT = FunctionType::get(Type::DoubleTy,arg_types,false);
TheModule->addTypeName("hlvm_f64_loge",FT);
hlvm_f64_loge =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f64_loge", TheModule);
}
return hlvm_f64_loge;
}
Function* get_hlvm_f64_log2()
{
if (! hlvm_f64_log2) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::DoubleTy);
FunctionType* FT = FunctionType::get(Type::DoubleTy,arg_types,false);
TheModule->addTypeName("hlvm_f64_log2",FT);
hlvm_f64_log2 =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f64_log2", TheModule);
}
return hlvm_f64_log2;
}
Function* get_hlvm_f64_log10()
{
if (! hlvm_f64_log10) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::DoubleTy);
FunctionType* FT = FunctionType::get(Type::DoubleTy,arg_types,false);
TheModule->addTypeName("hlvm_f64_log10",FT);
hlvm_f64_log10 =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f64_log10", TheModule);
}
return hlvm_f64_log10;
}
Function* get_hlvm_f64_squareroot()
{
if (! hlvm_f64_squareroot) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::DoubleTy);
FunctionType* FT = FunctionType::get(Type::DoubleTy,arg_types,false);
TheModule->addTypeName("hlvm_f64_squareroot",FT);
hlvm_f64_squareroot =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f64_squareroot", TheModule);
}
return hlvm_f64_squareroot;
}
Function* get_hlvm_f64_cuberoot()
{
if (! hlvm_f64_cuberoot) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::DoubleTy);
FunctionType* FT = FunctionType::get(Type::DoubleTy,arg_types,false);
TheModule->addTypeName("hlvm_f64_cuberoot",FT);
hlvm_f64_cuberoot =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f64_cuberoot", TheModule);
}
return hlvm_f64_cuberoot;
}
Function* get_hlvm_f64_factorial()
{
if (! hlvm_f64_factorial) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::DoubleTy);
FunctionType* FT = FunctionType::get(Type::DoubleTy,arg_types,false);
TheModule->addTypeName("hlvm_f64_factorial",FT);
hlvm_f64_factorial =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f64_factorial", TheModule);
}
return hlvm_f64_factorial;
}
Function* get_hlvm_f64_power()
{
if (! hlvm_f64_power) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::DoubleTy);
arg_types.push_back(Type::DoubleTy);
FunctionType* FT = FunctionType::get(Type::DoubleTy,arg_types,false);
TheModule->addTypeName("hlvm_f64_power",FT);
hlvm_f64_power =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f64_power", TheModule);
}
return hlvm_f64_ispinf;
}
Function* get_hlvm_f64_root()
{
if (! hlvm_f64_root) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::DoubleTy);
arg_types.push_back(Type::DoubleTy);
FunctionType* FT = FunctionType::get(Type::DoubleTy,arg_types,false);
TheModule->addTypeName("hlvm_f64_root",FT);
hlvm_f64_root =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f64_root", TheModule);
}
return hlvm_f64_ispinf;
}
Function* get_hlvm_f64_gcd()
{
if (! hlvm_f64_gcd) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::DoubleTy);
arg_types.push_back(Type::DoubleTy);
FunctionType* FT = FunctionType::get(Type::DoubleTy,arg_types,false);
TheModule->addTypeName("hlvm_f64_gcd",FT);
hlvm_f64_gcd =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f64_gcd", TheModule);
}
return hlvm_f64_ispinf;
}
Function* get_hlvm_f64_lcm()
{
if (! hlvm_f64_lcm) {
std::vector<const Type*> arg_types;
arg_types.push_back(Type::DoubleTy);
arg_types.push_back(Type::DoubleTy);
FunctionType* FT = FunctionType::get(Type::DoubleTy,arg_types,false);
TheModule->addTypeName("hlvm_f64_lcm",FT);
hlvm_f64_lcm =
new Function(FT, GlobalValue::ExternalLinkage,
"hlvm_f64_lcm", TheModule);
}
return hlvm_f64_ispinf;
}
CallInst* call_hlvm_f64_ispinf(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f64_ispinf(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f64_isninf(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f64_isninf(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f64_isnan(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f64_isnan(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f64_trunc(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f64_trunc(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f64_round(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f64_round(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f64_floor(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f64_floor(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f64_ceiling(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f64_ceiling(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f64_loge(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f64_loge(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f64_log2(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f64_log2(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f64_log10(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f64_log10(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f64_squareroot(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f64_squareroot(), args.begin(), args.end(),
"", TheBlock);
}
CallInst* call_hlvm_f64_cuberoot(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f64_cuberoot(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f64_factorial(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f64_factorial(), args.begin(), args.end(),
"", TheBlock);
}
CallInst* call_hlvm_f64_power(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f64_power(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f64_root(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f64_root(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f64_gcd(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f64_gcd(), args.begin(), args.end(), "",
TheBlock);
}
CallInst* call_hlvm_f64_lcm(const hlvm::ArgList& args)
{
return new CallInst(get_hlvm_f64_lcm(), args.begin(), args.end(), "",
TheBlock);
}
/// @}
};
}
namespace hlvm {
LLVMEmitter::LLVMEmitter()
: TheModule(0), TheFunction(0), TheEntryBlock(0), TheExitBlock(0),
EntryInsertionPoint(0), TheBlock(0)
{
}
LLVMEmitter*
new_LLVMEmitter()
{
return new LLVMEmitterImpl();
}
Module*
LLVMEmitter::StartModule(const std::string& ID)
{
hlvmAssert(TheModule == 0);
return TheModule = new Module(ID);
}
Module*
LLVMEmitter::FinishModule()
{
hlvmAssert(TheModule != 0);
Module* result = TheModule;
TheModule = 0;
return result;
}
void
LLVMEmitter::StartFunction(Function* F)
{
hlvmAssert(F != 0 && "Null function?");
hlvmAssert(F->empty() && "Function already emitted!");
// Ensure previous state is cleared
// operands.clear();
// enters.clear();
// exits.clear();
blocks.clear();
breaks.clear();
continues.clear();
// lvars.clear();
// Set up for new function
TheFunction = F;
// Instantiate an entry block for the alloca'd variables. This block
// is only used for such variables. By placing the alloca'd variables in
// the entry block, their allocation is free since the stack pointer
// must be adjusted anyway, all that happens is that it gets adjusted
// by a larger amount.
TheBlock = TheEntryBlock = new BasicBlock("entry",F);
// Instantiate a no-op as an insertion point for the entry point stuff such
// as the alloca variables and argument setup. This allows us to fill and
// terminate the entry block as usual while still retaining a point for
// insertion in the entry block that retains declaration order.
EntryInsertionPoint =
new BitCastInst(Constant::getNullValue(Type::Int32Ty),Type::Int32Ty,
"entry_point", TheEntryBlock);
// Create a new block for the return node, but don't insert it yet.
// TheExitBlock = new BasicBlock("exit");
}
void
LLVMEmitter::FinishFunction()
{
// The entry block was created to hold the automatic variables. We now
// need to terminate the block by branching it to the first active block
// in the function.
Function::iterator I = TheFunction->begin();
++I;
new BranchInst(&*I, &TheFunction->front());
hlvmAssert(blocks.empty());
hlvmAssert(breaks.empty());
hlvmAssert(continues.empty());
}
BasicBlock*
LLVMEmitter::pushBlock(const std::string& name)
{
TheBlock = new BasicBlock(name,TheFunction);
blocks.push_back(TheBlock);
return TheBlock;
}
BasicBlock*
LLVMEmitter::popBlock()
{
BasicBlock* result = blocks.back();
blocks.pop_back();
if (blocks.empty())
TheBlock = 0;
else
TheBlock = blocks.back();
return result;
}
BasicBlock*
LLVMEmitter::newBlock(const std::string& name)
{
blocks.pop_back();
TheBlock = new BasicBlock(name,TheFunction);
blocks.push_back(TheBlock);
return TheBlock;
}
Value*
LLVMEmitter::ConvertToBoolean(Value* V) const
{
const Type* Ty = V->getType();
if (Ty == Type::Int1Ty)
return V;
if (Ty->isInteger() || Ty->isFloatingPoint()) {
Constant* CI = Constant::getNullValue(V->getType());
return new ICmpInst(ICmpInst::ICMP_NE, V, CI, "i2b", TheBlock);
} else if (isa<GlobalValue>(V)) {
// GlobalValues always have non-zero constant address values, so always true
return ConstantInt::getTrue();
}
hlvmAssert(!"Don't know how to convert V into bool");
return ConstantInt::getTrue();
}
Value*
LLVMEmitter::Pointer2Value(Value* V) const
{
if (!isa<PointerType>(V->getType()))
return V;
// GetElementPtrInst* GEP = new GetElementPtrIns(V,
// ConstantInt::get(Type::Int32Ty,0),
// ConstantInt::get(Type::Int32Ty,0),
// "ptr2Value", TheBlock);
return new LoadInst(V,"ptr2Value", TheBlock);
}
bool
LLVMEmitter::IsNoopCast(Value* V, const Type* Ty)
{
// check signed to unsigned
const Type *VTy = V->getType();
if (VTy->canLosslesslyBitCastTo(Ty))
return true;
// Constant int to anything, to work around stuff like: "xor short X, int 1".
if (isa<ConstantInt>(V))
return true;
return false;
}
/// CastToType - Cast the specified value to the specified type if it is
/// not already that type.
Value *
LLVMEmitter::CastToType(Value *V, bool srcIsSigned, const Type *Ty,
bool destIsSigned, const std::string& newName)
{
// If they are the same type, no cast needed
if (V->getType() == Ty)
return V;
// Get the opcode necessary for the cast.
Instruction::CastOps Opcode =
CastInst::getCastOpcode(V, srcIsSigned, Ty, destIsSigned);
// If its a constant then we want a constant cast
if (Constant *C = dyn_cast<Constant>(V))
return ConstantExpr::getCast(Opcode, C, Ty);
// If its a cast instruction and we're casting back to the original type,
// which is bool, then just get the operand of the cast instead of emitting
// duplicate cast instructions. This is just an optimization of a frequently
// occurring case.
if (CastInst *CI = dyn_cast<CastInst>(V))
if (Ty == Type::Int1Ty && CI->getOperand(0)->getType() == Type::Int1Ty)
return CI->getOperand(0);
// Otherwise, just issue the cast
return CastInst::create(Opcode, V, Ty,
(newName.empty() ? V->getName() : newName), TheBlock);
}
void
LLVMEmitter::ResolveBreaks(BasicBlock* exit)
{
for (BranchList::iterator I = breaks.begin(), E = breaks.end(); I != E; ++I) {
(*I)->setOperand(0,exit);
}
breaks.clear();
}
void
LLVMEmitter::ResolveContinues(BasicBlock* entry)
{
for (BranchList::iterator I = continues.begin(), E = continues.end();
I != E; ++I) {
(*I)->setOperand(0,entry);
}
continues.clear();
}
/// Return the number of elements in the specified type that will need to be
/// loaded/stored if we copy this one element at a time.
unsigned
LLVMEmitter::getNumElements(const Type *Ty)
{
if (Ty->isFirstClassType()) return 1;
if (const StructType *STy = dyn_cast<StructType>(Ty)) {
unsigned NumElts = 0;
for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i)
NumElts += getNumElements(STy->getElementType(i));
return NumElts;
} else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
return ATy->getNumElements() * getNumElements(ATy->getElementType());
} else if (const VectorType* VTy = dyn_cast<VectorType>(Ty)) {
return VTy->getNumElements() * getNumElements(VTy->getElementType());
} else
hlvmAssert(!"Don't know how to count elements of this type");
return 0;
}
Constant*
LLVMEmitter::getFirstElement(GlobalVariable* GV)
{
ArgList indices;
TwoZeroIndices(indices);
return ConstantExpr::getGetElementPtr(GV, &indices[0], 2);
}
FunctionType*
LLVMEmitter::getFunctionType(
const std::string& name, const Type* resultTy,
const TypeList& args, bool varargs)
{
// The args might contain non-first-class typed arguments. We build a
// new argument list the contains the argument types after conversion.
TypeList Params;
// We can't have results that are not first class so we use the
// first argument to point to where the result should be stored and
// switch the result type to VoidTy.
if (!resultTy->isFirstClassType()) {
Params.push_back(getFirstClassType(resultTy));
resultTy = Type::VoidTy;
}
for (TypeList::const_iterator I = args.begin(), E = args.end(); I != E; ++I )
{
if ((*I)->isFirstClassType())
Params.push_back(*I);
else
Params.push_back(getFirstClassType(*I));
}
FunctionType* result = FunctionType::get(resultTy, Params, varargs);
if (!name.empty())
TheModule->addTypeName(name,result);
return result;
}
Type*
LLVMEmitter::getTextType()
{
return static_cast<LLVMEmitterImpl*>(this)->get_hlvm_text();
}
Type*
LLVMEmitter::getStreamType()
{
return static_cast<LLVMEmitterImpl*>(this)->get_hlvm_stream();
}
Type*
LLVMEmitter::getBufferType()
{
return static_cast<LLVMEmitterImpl*>(this)->get_hlvm_buffer();
}
FunctionType*
LLVMEmitter::getProgramType()
{
return static_cast<LLVMEmitterImpl*>(this)->get_hlvm_program_signature();
}
llvm::CmpInst* LLVMEmitter::emitNE(llvm::Value* V1, llvm::Value* V2){
if (V1->getType()->isFloatingPoint())
return new llvm::FCmpInst(llvm::FCmpInst::FCMP_ONE, V1, V2, "ne",TheBlock);
else
return new llvm::ICmpInst(llvm::ICmpInst::ICMP_NE, V1, V2, "ne",TheBlock);
}
llvm::CmpInst* LLVMEmitter::emitEQ(llvm::Value* V1, llvm::Value* V2){
if (V1->getType()->isFloatingPoint())
return new llvm::FCmpInst(llvm::FCmpInst::FCMP_OEQ, V1, V2, "eq",TheBlock);
else
return new llvm::ICmpInst(llvm::ICmpInst::ICMP_EQ, V1, V2, "eq",TheBlock);
}
llvm::CmpInst* LLVMEmitter::emitLT(llvm::Value* V1, llvm::Value* V2, bool sign){
if (V1->getType()->isFloatingPoint())
return new llvm::FCmpInst(llvm::FCmpInst::FCMP_OLT, V1, V2,"olt",TheBlock);
else if (sign)
return new llvm::ICmpInst(llvm::ICmpInst::ICMP_ULT, V1, V2,"ult",TheBlock);
else
return new llvm::ICmpInst(llvm::ICmpInst::ICMP_SLT, V1, V2,"slt",TheBlock);
}
llvm::CmpInst* LLVMEmitter::emitGT(llvm::Value* V1, llvm::Value* V2, bool sign){
if (V1->getType()->isFloatingPoint())
return new llvm::FCmpInst(llvm::FCmpInst::FCMP_OGT, V1, V2,"ogt",TheBlock);
else if (sign)
return new llvm::ICmpInst(llvm::ICmpInst::ICMP_SGT, V1, V2,"sgt",TheBlock);
else
return new llvm::ICmpInst(llvm::ICmpInst::ICMP_UGT, V1, V2,"ugt",TheBlock);
}
llvm::CmpInst* LLVMEmitter::emitLE(llvm::Value* V1, llvm::Value* V2, bool sign){
if (V1->getType()->isFloatingPoint())
return new llvm::FCmpInst(llvm::FCmpInst::FCMP_OLE, V1, V2,"ole",TheBlock);
else if (sign)
return new llvm::ICmpInst(llvm::ICmpInst::ICMP_ULE, V1, V2,"ule",TheBlock);
else
return new llvm::ICmpInst(llvm::ICmpInst::ICMP_SLE, V1, V2,"sle",TheBlock);
}
llvm::CmpInst* LLVMEmitter::emitGE(llvm::Value* V1, llvm::Value* V2, bool sign){
if (V1->getType()->isFloatingPoint())
return new llvm::FCmpInst(llvm::FCmpInst::FCMP_OGE, V1, V2,"oge",TheBlock);
else if (sign)
return new llvm::ICmpInst(llvm::ICmpInst::ICMP_SGE, V1, V2,"sge",TheBlock);
else
return new llvm::ICmpInst(llvm::ICmpInst::ICMP_UGE, V1, V2,"uge",TheBlock);
}
void
LLVMEmitter::emitAssign(Value* dest, Value* src)
{
// If the destination is a load instruction then its the result of a previous
// nested block so just get the first operand as the real destination.
if (isa<LoadInst>(dest))
dest = cast<LoadInst>(dest)->getOperand(0);
// The destination must be a pointer type
hlvmAssert(isa<PointerType>(dest->getType()));
// Get the type of the destination and source
const Type* destTy = cast<PointerType>(dest->getType())->getElementType();
const Type* srcTy = src->getType();
if (destTy->isFirstClassType()) {
// Can't store an aggregate to a first class type
hlvmAssert(srcTy->isFirstClassType());
if (destTy == srcTy) {
// simple case, the types match and they are both first class types,
// just emit a store instruction
emitStore(src,dest);
} else if (const PointerType* srcPT = dyn_cast<PointerType>(srcTy)) {
// The source is a pointer to the value to return so just get a
// pointer to its first element and store it since its pointing to
// a first class type. Assert that this is true.
hlvmAssert( srcPT->getElementType() == destTy );
ArgList idx;
TwoZeroIndices(idx);
GetElementPtrInst* GEP =
new GetElementPtrInst(src, &idx[0], 2, "", TheBlock);
emitStore(GEP,dest);
} else {
// they are both first class types and the source is not a pointer, so
// just cast them. FIXME: signedness
Value* V = CastToType(src, false, destTy, false, src->getName());
emitStore(V, dest);
}
}
else if (const PointerType* srcPT = dyn_cast<PointerType>(srcTy))
{
// We have an aggregate to copy
emitAggregateCopy(dest,src);
}
else if (Constant* srcC = dyn_cast<Constant>(src))
{
// We have a constant aggregate to move into an aggregate gvar. We must
// create a temporary gvar based on the constant in order to copy it.
GlobalVariable* GVar = NewGConst(srcTy, srcC, srcC->getName());
// Now we can aggregate copy it
emitAggregateCopy(dest, GVar);
}
}
/// Recursively traverse the potientially aggregate src/dest ptrs, copying all
/// of the elements from src to dest.
static void
CopyAggregate(
Value *DestPtr,
bool DestVolatile,
Value *SrcPtr,
bool SrcVolatile,
BasicBlock *BB)
{
assert(DestPtr->getType() == SrcPtr->getType() &&
"Cannot copy between two pointers of different type!");
const Type *ElTy = cast<PointerType>(DestPtr->getType())->getElementType();
if (ElTy->isFirstClassType()) {
Value *V = new LoadInst(SrcPtr, "tmp", SrcVolatile, BB);
new StoreInst(V, DestPtr, DestVolatile, BB);
} else if (const StructType *STy = dyn_cast<StructType>(ElTy)) {
Constant *Zero = ConstantInt::get(Type::Int32Ty, 0);
for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
Constant *Idx = ConstantInt::get(Type::Int32Ty, i);
Value *DElPtr = new GetElementPtrInst(DestPtr, Zero, Idx, "tmp", BB);
Value *SElPtr = new GetElementPtrInst(SrcPtr, Zero, Idx, "tmp", BB);
CopyAggregate(DElPtr, DestVolatile, SElPtr, SrcVolatile, BB);
}
} else {
const ArrayType *ATy = cast<ArrayType>(ElTy);
Constant *Zero = ConstantInt::get(Type::Int32Ty, 0);
for (unsigned i = 0, e = ATy->getNumElements(); i != e; ++i) {
Constant *Idx = ConstantInt::get(Type::Int32Ty, i);
Value *DElPtr = new GetElementPtrInst(DestPtr, Zero, Idx, "tmp", BB);
Value *SElPtr = new GetElementPtrInst(SrcPtr, Zero, Idx, "tmp", BB);
CopyAggregate(DElPtr, DestVolatile, SElPtr, SrcVolatile, BB);
}
}
}
/// EmitAggregateCopy - Copy the elements from SrcPtr to DestPtr, using the
/// GCC type specified by GCCType to know which elements to copy.
void
LLVMEmitter::emitAggregateCopy(
Value *DestPtr,
Value *SrcPtr )
{
// Make sure we're not mixing apples and oranges
hlvmAssert(DestPtr->getType() == SrcPtr->getType());
// Degenerate case, same pointer
if (DestPtr == SrcPtr)
return; // noop copy.
// If the type has just a few elements, then copy the elements directly
// using load/store. Otherwise use the llvm.memcpy.i64 intrinsic. This just
// saves a function call for really small structures and arrays.
const Type* Ty = SrcPtr->getType();
if (getNumElements(Ty) <= 8)
CopyAggregate(DestPtr, false, SrcPtr, false, TheBlock);
else
emitMemCpy(DestPtr, SrcPtr, ConstantExpr::getSizeOf(Ty));
}
ReturnInst*
LLVMEmitter::emitReturn(Value* retVal)
{
// First deal with the degenerate case, a void return
if (retVal == 0) {
hlvmAssert(getReturnType() == Type::VoidTy);
return new ReturnInst(0,TheBlock);
}
// Now, deal with first class result types. Becasue of the way function
// types are generated, a void type at this point indicates an aggregate
// result. If we don't have a void type, then it must be a first class result.
const Type* resultTy = retVal->getType();
if (getReturnType() != Type::VoidTy) {
Value* result = 0;
if (const PointerType* PTy = dyn_cast<PointerType>(resultTy)) {
// must be an autovar or global var, just load the value
hlvmAssert(PTy->getElementType() == getReturnType());
result = emitLoad(retVal,getBlockName() + "_result");
} else if (resultTy != getReturnType()) {
hlvmAssert(resultTy->isFirstClassType());
// FIXME: signedness
result = CastToType(retVal, false, getReturnType(), false,
getBlockName()+"_result");
} else {
hlvmAssert(resultTy->isFirstClassType());
result = retVal;
}
hlvmAssert(result && "No result for function");
return new ReturnInst(result,TheBlock);
}
// Now, deal with the aggregate result case. At this point the function return
// type must be void and the first argument must be a pointer to the storage
// area for the result.
hlvmAssert(getReturnType() == Type::VoidTy);
// Get the first argument.
hlvmAssert(!TheFunction->arg_empty());
Argument* result_arg = TheFunction->arg_begin();
// Both the first argument and the result should have the same type which
// both should be pointer to the aggregate
hlvmAssert(result_arg->getType() == resultTy);
// Copy the aggregate result
emitAggregateCopy(result_arg, retVal);
// Emit the void return
return new ReturnInst(0, TheBlock);
}
CallInst*
LLVMEmitter::emitCall(Function* F, const ArgList& args)
{
// Detect the aggregate result case
if ((F->getReturnType() == Type::VoidTy) &&
(args.size() == F->arg_size() - 1)) {
const Type* arg1Ty = F->arg_begin()->getType();
if (const PointerType* PTy = dyn_cast<PointerType>(arg1Ty))
{
// This is the case where the result is a temporary variable that
// holds the aggregate and is passed as the first argument
const Type* elemTy = PTy->getElementType();
hlvmAssert(!elemTy->isFirstClassType());
// Get a temporary for the result
AllocaInst* result = NewAutoVar(elemTy, F->getName() + "_result");
// Install the temporary result area into a new arg list
ArgList newArgs;
newArgs.push_back(result);
// Copy the other arguments
for (ArgList::const_iterator I = args.begin(), E = args.end();
I != E; ++I)
if (isa<Constant>(*I) && !isa<GlobalValue>(*I) &&
!(*I)->getType()->isFirstClassType())
newArgs.push_back(NewGConst((*I)->getType(),
cast<Constant>(*I), (*I)->getName()));
else
newArgs.push_back(*I);
// Generate the call
return new CallInst(F, newArgs.begin(), newArgs.end(), "", TheBlock);
}
}
// The result must be a first class type at this point, ensure it
hlvmAssert(F->getReturnType()->isFirstClassType());
// Copy the other arguments
ArgList newArgs;
for (ArgList::const_iterator I = args.begin(), E = args.end();
I != E; ++I)
if (isa<Constant>(*I) && !isa<GlobalValue>(*I) &&
!(*I)->getType()->isFirstClassType())
newArgs.push_back(NewGConst((*I)->getType(),
cast<Constant>(*I), (*I)->getName()));
else
newArgs.push_back(*I);
return new CallInst(F, newArgs.begin(), newArgs.end(),
F->getName() + "_result", TheBlock);
}
void
LLVMEmitter::emitMemCpy(
Value *dest,
Value *src,
Value *size
)
{
const Type *SBP = PointerType::get(Type::Int8Ty);
ArgList args;
args.push_back(CastToType(dest, false, SBP, false, ""));
args.push_back(CastToType(src, false, SBP, false, ""));
args.push_back(size);
args.push_back(ConstantInt::get(Type::Int32Ty, 0u));
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
new CallInst(emimp->get_llvm_memcpy(), args.begin(), args.end(), "",
TheBlock);
}
/// Emit an llvm.memmove.i64 intrinsic
void
LLVMEmitter::emitMemMove(
Value *dest,
Value *src,
Value *size
)
{
const Type *SBP = PointerType::get(Type::Int8Ty);
ArgList args;
args.push_back(CastToType(dest, false, SBP, false, ""));
args.push_back(CastToType(src, false, SBP, false, ""));
args.push_back(size);
args.push_back(ConstantInt::get(Type::Int32Ty, 0u));
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
new CallInst(emimp->get_llvm_memmove(), args.begin(), args.end(), "",
TheBlock);
}
/// Emit an llvm.memset.i64 intrinsic
void
LLVMEmitter::emitMemSet(
Value *dest,
Value *val,
Value *size
)
{
const Type *SBP = PointerType::get(Type::Int8Ty);
ArgList args;
args.push_back(CastToType(dest, false, SBP, false, ""));
args.push_back(CastToType(val, false, Type::Int8Ty, false, ""));
args.push_back(size);
args.push_back(ConstantInt::get(Type::Int32Ty, 0u));
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
new CallInst(emimp->get_llvm_memset(), args.begin(), args.end(), "",
TheBlock);
}
CallInst*
LLVMEmitter::emitOpen(llvm::Value* strm)
{
std::vector<llvm::Value*> args;
if (const llvm::PointerType* PT =
llvm::dyn_cast<llvm::PointerType>(strm->getType()))
{
const llvm::Type* Ty = PT->getElementType();
if (Ty == llvm::Type::Int8Ty) {
args.push_back(strm);
} else if (llvm::isa<ArrayType>(Ty) &&
cast<ArrayType>(Ty)->getElementType() == Type::Int8Ty) {
ArgList indices;
this->TwoZeroIndices(indices);
args.push_back(this->emitGEP(strm,indices));
} else
hlvmAssert(!"Array element type is not Int8Ty");
} else
hlvmAssert(!"OpenOp parameter is not a pointer");
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
return emimp->call_hlvm_stream_open(args,"open");
}
CallInst*
LLVMEmitter::emitClose(llvm::Value* strm)
{
std::vector<llvm::Value*> args;
args.push_back(strm);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
return emimp->call_hlvm_stream_close(args);
}
CallInst*
LLVMEmitter::emitRead(llvm::Value* strm,llvm::Value* arg2, llvm::Value* arg3)
{
std::vector<llvm::Value*> args;
args.push_back(strm);
args.push_back(arg2);
args.push_back(arg3);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
return emimp->call_hlvm_stream_read(args,"read");
}
CallInst*
LLVMEmitter::emitWrite(llvm::Value* strm,llvm::Value* arg2)
{
std::vector<llvm::Value*> args;
args.push_back(strm);
args.push_back(arg2);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
CallInst* result = 0;
if (llvm::isa<llvm::PointerType>(arg2->getType()))
if (llvm::cast<llvm::PointerType>(arg2->getType())->getElementType() ==
llvm::Type::Int8Ty)
result = emimp->call_hlvm_stream_write_string(args,"write");
if (arg2->getType() == emimp->get_hlvm_text())
result = emimp->call_hlvm_stream_write_text(args,"write");
else if (arg2->getType() == emimp->get_hlvm_buffer())
result = emimp->call_hlvm_stream_write_buffer(args,"write");
return result;
}
CallInst*
LLVMEmitter::emitIsPInf(Value* V)
{
std::vector<llvm::Value*> args;
args.push_back(V);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
hlvmAssert(V->getType()->isFloatingPoint());
if (Type::FloatTy == V->getType())
return emimp->call_hlvm_f32_ispinf(args);
return emimp->call_hlvm_f64_ispinf(args);
}
CallInst*
LLVMEmitter::emitIsNInf(Value* V)
{
std::vector<llvm::Value*> args;
args.push_back(V);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
hlvmAssert(V->getType()->isFloatingPoint());
if (Type::FloatTy == V->getType())
return emimp->call_hlvm_f32_isninf(args);
return emimp->call_hlvm_f64_isninf(args);
}
CallInst*
LLVMEmitter::emitIsNan(Value* V)
{
std::vector<llvm::Value*> args;
args.push_back(V);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
hlvmAssert(V->getType()->isFloatingPoint());
if (Type::FloatTy == V->getType())
return emimp->call_hlvm_f32_isnan(args);
return emimp->call_hlvm_f64_isnan(args);
}
CallInst*
LLVMEmitter::emitTrunc(Value* V)
{
std::vector<llvm::Value*> args;
args.push_back(V);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
hlvmAssert(V->getType()->isFloatingPoint());
if (Type::FloatTy == V->getType())
return emimp->call_hlvm_f32_trunc(args);
return emimp->call_hlvm_f64_trunc(args);
}
CallInst*
LLVMEmitter::emitRound(Value* V)
{
std::vector<llvm::Value*> args;
args.push_back(V);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
hlvmAssert(V->getType()->isFloatingPoint());
if (Type::FloatTy == V->getType())
return emimp->call_hlvm_f32_round(args);
return emimp->call_hlvm_f64_round(args);
}
CallInst*
LLVMEmitter::emitFloor(Value* V)
{
std::vector<llvm::Value*> args;
args.push_back(V);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
hlvmAssert(V->getType()->isFloatingPoint());
if (Type::FloatTy == V->getType())
return emimp->call_hlvm_f32_floor(args);
return emimp->call_hlvm_f64_floor(args);
}
CallInst*
LLVMEmitter::emitCeiling(Value* V)
{
std::vector<llvm::Value*> args;
args.push_back(V);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
hlvmAssert(V->getType()->isFloatingPoint());
if (Type::FloatTy == V->getType())
return emimp->call_hlvm_f32_ceiling(args);
return emimp->call_hlvm_f64_ceiling(args);
}
CallInst*
LLVMEmitter::emitLogE(Value* V)
{
std::vector<llvm::Value*> args;
args.push_back(V);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
hlvmAssert(V->getType()->isFloatingPoint());
if (Type::FloatTy == V->getType())
return emimp->call_hlvm_f32_loge(args);
return emimp->call_hlvm_f64_loge(args);
}
CallInst*
LLVMEmitter::emitLog2(Value* V)
{
std::vector<llvm::Value*> args;
args.push_back(V);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
hlvmAssert(V->getType()->isFloatingPoint());
if (Type::FloatTy == V->getType())
return emimp->call_hlvm_f32_log2(args);
return emimp->call_hlvm_f64_log2(args);
}
CallInst*
LLVMEmitter::emitLog10(Value* V)
{
std::vector<llvm::Value*> args;
args.push_back(V);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
hlvmAssert(V->getType()->isFloatingPoint());
if (Type::FloatTy == V->getType())
return emimp->call_hlvm_f32_log10(args);
return emimp->call_hlvm_f64_log10(args);
}
CallInst*
LLVMEmitter::emitSquareRoot(Value* V)
{
std::vector<llvm::Value*> args;
args.push_back(V);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
hlvmAssert(V->getType()->isFloatingPoint());
if (Type::FloatTy == V->getType())
return emimp->call_hlvm_f32_squareroot(args);
return emimp->call_hlvm_f64_squareroot(args);
}
CallInst*
LLVMEmitter::emitCubeRoot(Value* V)
{
std::vector<llvm::Value*> args;
args.push_back(V);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
hlvmAssert(V->getType()->isFloatingPoint());
if (Type::FloatTy == V->getType())
return emimp->call_hlvm_f32_cuberoot(args);
return emimp->call_hlvm_f64_cuberoot(args);
}
CallInst*
LLVMEmitter::emitFactorial(Value* V)
{
std::vector<llvm::Value*> args;
args.push_back(V);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
hlvmAssert(V->getType()->isFloatingPoint());
if (Type::FloatTy == V->getType())
return emimp->call_hlvm_f32_factorial(args);
return emimp->call_hlvm_f64_factorial(args);
}
CallInst*
LLVMEmitter::emitPower(Value* V1,Value*V2)
{
std::vector<llvm::Value*> args;
args.push_back(V1);
args.push_back(V2);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
hlvmAssert(V1->getType()->isFloatingPoint());
hlvmAssert(V2->getType()->isFloatingPoint());
if (Type::FloatTy == V1->getType())
return emimp->call_hlvm_f32_power(args);
return emimp->call_hlvm_f64_power(args);
}
CallInst*
LLVMEmitter::emitRoot(Value* V1,Value*V2)
{
std::vector<llvm::Value*> args;
args.push_back(V1);
args.push_back(V2);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
hlvmAssert(V1->getType()->isFloatingPoint());
hlvmAssert(V2->getType()->isFloatingPoint());
if (Type::FloatTy == V1->getType())
return emimp->call_hlvm_f32_root(args);
return emimp->call_hlvm_f64_root(args);
}
CallInst*
LLVMEmitter::emitGCD(Value* V1,Value*V2)
{
std::vector<llvm::Value*> args;
args.push_back(V1);
args.push_back(V2);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
hlvmAssert(V1->getType()->isFloatingPoint());
hlvmAssert(V2->getType()->isFloatingPoint());
if (Type::FloatTy == V1->getType())
return emimp->call_hlvm_f32_gcd(args);
return emimp->call_hlvm_f64_gcd(args);
}
CallInst*
LLVMEmitter::emitLCM(Value* V1,Value*V2)
{
std::vector<llvm::Value*> args;
args.push_back(V1);
args.push_back(V2);
LLVMEmitterImpl* emimp = static_cast<LLVMEmitterImpl*>(this);
hlvmAssert(V1->getType()->isFloatingPoint());
hlvmAssert(V2->getType()->isFloatingPoint());
if (Type::FloatTy == V1->getType())
return emimp->call_hlvm_f32_lcm(args);
return emimp->call_hlvm_f64_lcm(args);
}
}