Kaleidoscope

最新推荐文章于 2024-08-27 08:54:49 发布
最新推荐文章于 2024-08-27 08:54:49 发布
阅读量371 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tailuzhecom/article/details/85296488
版权

LLVM Tutorial

chapter 1

  • Kaleidoscope语言介绍
  1. 面向过程
  2. 编译器支持JIT
  3. 只有double数据类型
  • 用Kaleidoscope来计算Fibonacci数列
# Compute the x'th fibonacci number
def fib(x)
	if x < 3 then
		1
	else
		fib(x-1) + fib(x-2)
# This expression will compute the 40th number.
fib(40)
  • 图灵完备

chapter 3

LLVMContext和IRBuilder声明

LLVMContext TheContext;
IRBuilder<> Builder(TheContext);

Module使用：

std::unique_ptr<Module> TheModule;
TheModule = llvm::make_unique<Module>("my cool jit", TheContext);

llvm Makefile

LLVM_DIR = /usr/lib/llvm-3.9
CXXFLAGS = -g -std=c++11 -Wall -Wno-deprecated -Wno-unused -fpermissive -Wno-write-strings
CXXFLAGS += `${LLVM_DIR}/bin/llvm-config --cxxflags`
LDFLAGS += `${LLVM_DIR}/bin/llvm-config --ldflags`
LLVMLIBS = `${LLVM_DIR}/bin/llvm-config --libs`
LLVMLIBS += `${LLVM_DIR}/bin/llvm-config --system-libs`
CXX = clang++

all:
	${CXX} llvm_test.cpp ${CXXFLAGS} ${LDFLAGS} ${LLVMLIBS} -o llvm_test

llvm demo

  • 创建函数，调用函数，运算
#include <iostream>
#include "llvm/IR/Function.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Verifier.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/ADT/APFloat.h"
#include <memory>
#include <vector>
#include <map>

using namespace llvm;

llvm::LLVMContext TheContext;
IRBuilder<> Builder(TheContext);
std::unique_ptr<Module> TheModule;
std::map<std::string, Value *> NamedValues;

int main() {
    TheModule = make_unique<Module>("llvm_test", TheContext);
    std::vector<Type*> Doubles(2, Type::getDoubleTy(TheContext));  // 形参类型声明
    Doubles.push_back(Type::getInt32Ty(TheContext));

    FunctionType *FT = FunctionType::get(Type::getDoubleTy(TheContext),
            Doubles, false);    // 创建函数类型，param2不能为NULL
    Function *F = Function::Create(FT, Function::ExternalLinkage,
            "add", TheModule.get());    // 函数声明，函数名为add

    // 声明形参,给形参标注变量名
    std::vector<std::string> name_vec = {"a", "b", "c"};
    unsigned idx = 0;
    for (auto &arg : F->args())
        arg.setName(name_vec[idx++]);

    // 创建一个基本块，名字为entry，属于函数F
    BasicBlock *BB = BasicBlock::Create(TheContext, "entry", F);
    BasicBlock *BB1 = BasicBlock::Create(TheContext, "label1", F);
    Builder.SetInsertPoint(BB);  // 要先设置InsertPoint，才能生成IR

    for (auto &Arg : F->args())
        NamedValues[Arg.getName()] = &Arg;

    // 创建返回值，返回值为Float Constant 0.0
    Builder.CreateRet(ConstantFP::get(TheContext, APFloat(0.0)));

    Builder.SetInsertPoint(BB1);
    Builder.CreateRet(ConstantFP::get(TheContext, APFloat(1.0)));

    // 运算
    Value *addtmp = Builder.CreateFAdd(NamedValues["a"], NamedValues["b"], "");
    Builder.CreateFSub(NamedValues["a"], addtmp, "");
    Builder.CreateFMul(NamedValues["a"], NamedValues["b"], "");
    Builder.CreateFDiv(NamedValues["a"], NamedValues["b"], "");
    Value *L = Builder.CreateFCmpULT(NamedValues["a"], NamedValues["b"], "");   // float-point less than
    Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "");     // uitofp:unsigned int convert to float-point value

    // 打印生成的llvmIR
    TheModule->print(errs(), nullptr);  // errs() from Verifier.h
    return 0;
}

生成的llvm IR:

define double @add(double %a, double %b, i32 %c) {
entry:
  ret double 0.000000e+00

label1:                                           ; No predecessors!
  ret double 1.000000e+00
  %0 = fadd double %a, %b
  %1 = fsub double %a, %0
  %2 = fmul double %a, %b
  %3 = fdiv double %a, %b
  %4 = fcmp ult double %a, %b
  %5 = uitofp i1 %4 to double
}
  • if-then-else
#include <iostream>
#include "llvm/IR/Function.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Verifier.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/ADT/APFloat.h"
#include <memory>
#include <vector>
#include <map>

using namespace llvm;

llvm::LLVMContext TheContext;
IRBuilder<> Builder(TheContext);
std::unique_ptr<Module> TheModule;
std::map<std::string, Value *> NamedValues;

void llvm_test1() {
    TheModule = make_unique<Module>("llvm_test", TheContext);
    std::vector<Type*> Doubles(3, Type::getDoubleTy(TheContext));  // 形参类型声明

    FunctionType *FT = FunctionType::get(Type::getDoubleTy(TheContext),
            Doubles, false);    // 创建函数类型
    Function *F = Function::Create(FT, Function::ExternalLinkage,
            "func", TheModule.get());    // 函数声明，函数名为func

    // 声明形参,给形参标注变量名
    std::vector<std::string> name_vec = {"a", "b", "c"};
    unsigned idx = 0;
    for (auto &arg : F->args())
        arg.setName(name_vec[idx++]);

    for (auto &Arg : F->args())
        NamedValues[Arg.getName()] = &Arg;

    // 创建一个基本块，名字为entry，属于函数F
    BasicBlock *BB = BasicBlock::Create(TheContext, "entry", F);
    Builder.SetInsertPoint(BB);


    BasicBlock *then_block = BasicBlock::Create(TheContext, "then", F);
    BasicBlock *else_block = BasicBlock::Create(TheContext, "else", F);
    BasicBlock *merge_block = BasicBlock::Create(TheContext, "merge", F);

    Value *CondV = NamedValues["c"];
    CondV = Builder.CreateFCmpONE(ConstantFP::get(TheContext, APFloat(0.0)), CondV, "ifcond");
    Builder.CreateCondBr(CondV, then_block, else_block);

    Builder.SetInsertPoint(then_block);
    Value *then_val = Builder.CreateFAdd(NamedValues["a"], NamedValues["b"], "");
    Builder.CreateBr(merge_block);

    Builder.SetInsertPoint(else_block);
    Value *else_val = Builder.CreateFMul(NamedValues["a"], NamedValues["b"], "");
    Builder.CreateBr(merge_block);

    Builder.SetInsertPoint(merge_block);
    PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp");
    PN->addIncoming(then_val, then_block);
    PN->addIncoming(else_val, else_block);

    // 打印生成的llvmIR
    TheModule->print(errs(), nullptr);  // errs() from Verifier.h
}


int main() {
    llvm_test1();
}

生成的llvm ir

define double @func(double %a, double %b, double %c) {
entry:
  %ifcond = fcmp one double 0.000000e+00, %c
  br i1 %ifcond, label %then, label %else

then:                                             ; preds = %entry
  %0 = fadd double %a, %b
  br label %merge

else:                                             ; preds = %entry
  %1 = fmul double %a, %b
  br label %merge

merge:                                            ; preds = %else, %then
  %iftmp = phi double [ %0, %then ], [ %1, %else ]
}
  • alloca，load，store
#include <iostream>
#include "llvm/IR/Function.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Verifier.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/ADT/APFloat.h"
#include <memory>
#include <vector>
#include <map>

using namespace llvm;

llvm::LLVMContext TheContext;
IRBuilder<> Builder(TheContext);
std::unique_ptr<Module> TheModule;
std::map<std::string, AllocaInst*> NamedValues;

void llvm_test1() {
    TheModule = make_unique<Module>("llvm_test", TheContext);
    FunctionType *FT = FunctionType::get(Type::getVoidTy(TheContext), std::vector<Type*>(), false);
    Function *F = Function::Create(FT, Function::ExternalLinkage, "main", TheModule.get());
    BasicBlock *entry_block = BasicBlock::Create(TheContext, "entry", F);
    Builder.SetInsertPoint(entry_block);
    AllocaInst *a_ptr = Builder.CreateAlloca(Type::getDoubleTy(TheContext), nullptr, "a");
    AllocaInst *b_ptr = Builder.CreateAlloca(Type::getDoubleTy(TheContext), nullptr, "b");
    Builder.CreateStore(ConstantFP::get(TheContext, APFloat(1.0)), a_ptr);	// store 1.0 a_ptr
    Builder.CreateStore(ConstantFP::get(TheContext, APFloat(2.0)), b_ptr);	// store 2.0 b_ptr

    Value *tmp1 = Builder.CreateLoad(a_ptr, "");	// %1 = load a_ptr 
    Value *tmp2 = Builder.CreateLoad(b_ptr, "");  // %2 = load b_ptr

    Builder.CreateStore(tmp1, b_ptr);
    Builder.CreateStore(tmp2, a_ptr);

    AllocaInst *c_ptr = Builder.CreateAlloca(Type::getInt32Ty(TheContext), nullptr, "c");
    AllocaInst *d_ptr = Builder.CreateAlloca(Type::getInt32Ty(TheContext), nullptr, "d");
    Builder.CreateStore(ConstantInt::get(TheContext, APInt(32, 1)), c_ptr);   // APInt第一个参数为整数的位数
    Builder.CreateStore(ConstantInt::get(TheContext, APInt(32, 1)), d_ptr);
    Value *tmp3 = Builder.CreateLoad(c_ptr, "");
    Value *tmp4 = Builder.CreateLoad(d_ptr, "");
    Value *tmp5 = Builder.CreateAdd(tmp3, tmp4);
    Builder.CreateStore(tmp5, c_ptr);

    // 打印生成的llvmIR
    TheModule->print(errs(), nullptr);  // errs() from Verifier.h
}


int main() {
    llvm_test1();
}

输出的llvm ir

define void @main() {
entry:
  %a = alloca double
  %b = alloca double
  store double 1.000000e+00, double* %a
  store double 2.000000e+00, double* %b
  %0 = load double, double* %a
  %1 = load double, double* %b
  store double %0, double* %b
  store double %1, double* %a
  %c = alloca i32
  %d = alloca i32
  store i32 1, i32* %c
  store i32 1, i32* %d
  %2 = load i32, i32* %c
  %3 = load i32, i32* %d
  %4 = add i32 %2, %3
  store i32 %4, i32* %c
}
  • 将生成的llvm ir输出到一个文件中
 std::ofstream fs("output.txt");
std::ostream& os = fs;
 llvm::raw_os_ostream llvm_os(os);  //　需要#include "llvm/Support/raw_os_ostream"
TheModule->print(llvm_os, nullptr);
  • 显示"hello wrold!"
#include <iostream>
#include "llvm/IR/Function.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Verifier.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/ADT/APFloat.h"
#include "llvm/Support/raw_os_ostream.h"
#include <memory>
#include <vector>
#include <map>
#include <fstream>
#include <ostream>
using namespace llvm;

llvm::LLVMContext TheContext;
IRBuilder<> Builder(TheContext);
std::unique_ptr<Module> TheModule = make_unique<Module>("llvm_test", TheContext);
std::map<std::string, AllocaInst*> NamedValues;

void llvm_test1() {
    //TheModule = make_unique<Module>("llvm_test", TheContext);
    FunctionType *FT = FunctionType::get(Type::getVoidTy(TheContext), std::vector<Type*>(), false);
    Function *F = Function::Create(FT, Function::ExternalLinkage, "main", TheModule.get());
    BasicBlock *entry_block = BasicBlock::Create(TheContext, "entry", F);
    Builder.SetInsertPoint(entry_block);
    Value* helloworld_str = Builder.CreateGlobalStringPtr("hello world!\n");　　// 创建字符常量
    std::vector<Type*> puts_args;　
    puts_args.push_back(Builder.getInt8Ty()->getPointerTo());
    ArrayRef<Type*> args_ref(puts_args);
    FunctionType * puts_type = FunctionType::get(Builder.getInt32Ty(), args_ref, false);
    Function* puts_func = Function::Create(puts_type, Function::ExternalLinkage, "puts", TheModule.get());   //声明puts函数
    Builder.CreateCall(puts_func, helloworld_str);　// 调用puts函数
    Builder.CreateRetVoid();	
    outs() << *TheModule;
}

int main() {
    llvm_test1();
}

生成的llvm ir，指令lli命令后直接运行

; ModuleID = 'llvm_test'
source_filename = "llvm_test"

@0 = private unnamed_addr constant [14 x i8] c"hello world!\0A\00"

define void @main() {
entry:
  %0 = call i32 @puts(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @0, i32 0, i32 0))
  ret void
}

declare i32 @puts(i8*)
  • StructType, getelementptr, bitcast（将类型A转换为类型B，转换的过程中不改变原本的数据，相当于只是改变读的方式）
#include <iostream>
#include "llvm/IR/Function.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Verifier.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/ADT/APFloat.h"
#include "llvm/Support/raw_os_ostream.h"
#include <memory>
#include <vector>
#include <map>
#include <fstream>
#include <ostream>
using namespace llvm;

llvm::LLVMContext TheContext;
IRBuilder<> Builder(TheContext);
std::unique_ptr<Module> TheModule = make_unique<Module>("llvm_test", TheContext);
std::map<std::string, AllocaInst*> NamedValues;

void llvm_test1() {
    //TheModule = make_unique<Module>("llvm_test", TheContext);

    FunctionType *FT = FunctionType::get(Type::getVoidTy(TheContext), std::vector<Type*>(), false);
    Function *F = Function::Create(FT, Function::ExternalLinkage, "main", TheModule.get());
    BasicBlock *entry_block = BasicBlock::Create(TheContext, "entry", F);
    Builder.SetInsertPoint(entry_block);

    std::vector<Type*> types;
    types.push_back(Type::getDoubleTy(TheContext));
    types.push_back(Type::getInt32Ty(TheContext));
    StructType *st = StructType::create(TheContext, types, "A");
    AllocaInst *a_ptr = Builder.CreateAlloca(st);
    Value *dest = Builder.CreateGEP(a_ptr, ConstantInt::get(Type::getInt32Ty(TheContext), APInt(32, 1)));
    Builder.CreateBitCast(a_ptr, Type::getInt32Ty(TheContext)->getPointerTo());
    Builder.CreateRetVoid();
    outs() << *TheModule;
}


int main() {
    llvm_test1();
}

生成的llvm ir

; ModuleID = 'llvm_test'
source_filename = "llvm_test"

%A = type { double, i32 }

define void @main() {
entry:
  %0 = alloca %A
  %1 = getelementptr %A, %A* %0, i32 1
  %2 = bitcast %A* %0 to i32*
  ret void
}
  • 创建vable(创建未定义类型的指针）
void define_vtable() {
    StructType *foo = StructType::create(TheContext, "Foo");   // 注意一定要用create不能用get，否则后面无法调用setBody()
    StructType *vtable = StructType::create(TheContext, "vtable");
    auto *foo_ptr = foo->getPointerTo();

    std::vector<Type*> fields({vtable->getPointerTo(), Type::getInt32Ty(TheContext), Type::getInt32Ty(TheContext)});
    FunctionType *foo_create_default_type = FunctionType::get(Type::getVoidTy(TheContext), {foo_ptr},
                                                              false);
    Function *foo_create_default = Function::Create(foo_create_default_type, Function::ExternalLinkage,
                                                    "Foo_Create_Default", TheModule.get());
    func_map["Foo_Create_Default"] = foo_create_default;
    for (auto &arg : foo_create_default->args())
        arg.setName("this");
    Function *func_ptr = TheModule->getFunction("Foo_Create_Default");
    BasicBlock *entry_block = BasicBlock::Create(TheContext, "entry", func_ptr);
    Builder.SetInsertPoint(entry_block);


    Builder.CreateAlloca(foo->getPointerTo());
    //foo->setBody({Type::getInt32Ty(TheContext), Type::getInt32Ty(TheContext)});
    foo->setBody(fields);
    vtable->setBody({foo_create_default_type});
    outs() << *TheModule;
}

生成的llvm ir:

%Foo = type { %vtable*, i32, i32 }
%vtable = type { void (%Foo*) }

define void @Foo_Create_Default(%Foo* %this) {
entry:
  %0 = alloca %Foo*
}
  • 内置的printf函数使用
void print_test() {
    Function *print_func = get_printf(TheModule.get());
    FunctionType *func_type = FunctionType::get(Type::getVoidTy(TheContext), std::vector<Type*>(), false);
    Function *main = Function::Create(func_type, Function::ExternalLinkage, "main", TheModule.get());
    BasicBlock *entry_block = BasicBlock::Create(TheContext, "entry", main);
    Builder.SetInsertPoint(entry_block);
    Value *print_arg = ConstantInt::get(Type::getInt32Ty(TheContext), APInt(32, 1));
    Builder.CreateCall(print_func, {Builder.CreateGlobalStringPtr("in llvm fun, value = %d\n"), print_arg});
    Builder.CreateCall(print_func, {Builder.CreateGlobalStringPtr("%s\n"), Builder.CreateGlobalStringPtr("hello world!")});
    outs() << *TheModule;
}
tailuzhecom
关注
LLVM编译器Kaleidoscope(万花筒)入门教学
weixin_45331809的博客
03-06 2391
LLVM学习笔记 LLVM是一款比较新的编译器工具。网上对LLVM使用的相关文档比较少，大部分都是官方给的例子。翻译过后晦涩难懂。在次，写一篇心得，也是为了课程任务，也是为了自己的一个学习总结，总结一下LLVM的学习过程，以及LLVM的万花筒实例。 首先和大家说一说LLVM是干什么的。LLVM是一个编译器。一个帮助你更简单写编译器的一个框架。在LLVM中有很多文件，这些文件我们都看不懂，也不用管，...
Kaleidoscope for Mac(文件和图像比较工具)
macxingchendahai的博客
11-08 612
还记得以前经常玩的【两张图片找不同】的游戏吗，Kaleidoscope for Mac是Mac OS平台上一款很强大的文件和图像比较工具，有了kaleidoscope mac这个软件工具，以后我们再也不用花费巨大的人力去找了 。 kaleidoscope mac软件简介 Kaleidoscope Mac版是Mac OS平台上一款很强大的文件和图像比较工具，支持任何文本文件和 jpeg、tiff、png、psd 等格式的图像文件，同时和 git、svn 等版本控制工具能够完美的结合，在几秒钟内就可以查找回顾
Kaleidoscope 开源项目使用教程
最新发布
gitblog_00158的博客
08-27 486
Kaleidoscope 开源项目使用教程 kaleidoscopeStatically-checked inline matching on regular expressions in Scala项目地址:https://gitcode.com/gh_mirrors/kalei/kaleidoscope 1. 项目的目录结构及介绍 Kaleidoscope 项目的目录结构如下： kaleid...
Kaleidoscope: Tutrial Introduction and the Lexer
qiusi0225的博客
09-19 395
Kaleidoscope: Tutorial Introduction and the LexerBasic LanguageKaleidoscopeThe Lexer 词法分析器 Basic Language Kaleidoscope 使用Kaleidoscope作为玩具语言,我们可以定义函数,使用条件,数学等. 唯一的数据类型是64位浮点类型(C语言中称为&amp;quot;double&amp;quot;),并且不需要类型声明...
kaleidoscope:万花筒语言和编译器
06-26
万花筒语言和编译器 这是我基于并受到启发的 Kaleidoscope 语言和编译器的工作。 由于 Kaleidoscope LLVM 教程不关心设计原则和内容，我试图以更简洁的方式重新创建教程。 后来我想整合的词法分析器和作为AST解析器，而不是编写自己的词法和语法分析器从教程。 为什么在 GitHub 上 这主要是一个学习词法分析器、解析器和编译器的个人项目。 GitHub 既可以作为在线备份，也可以展示我的学习经验。 安装 首先，您必须编译万花筒编译器本身。 在 git repo 之外创建一个目录，然后 cd 进入其中。 cmake ~/path/to/kaleidoscope/gitrepo && make 用法 kaleidoscope二进制文件位于src文件夹中。 目前 kaleidoscope 只解析输入并显示解析了哪个表达式。 $ ./kaleidoscope re
LLVM教程1——Kaleidoscope 介绍和语法分析器
再走一步
12-13 760
LLVM官方文档教程示例1
kaleidoscope:DartPixi万花筒浏览器
05-09
在本文中，我们将深入探讨一个名为"Kaleidoscope"的项目，它是用Dart语言和Pixi库构建的万花筒浏览器。这个项目为开发者提供了一种新颖的方式来展示Dart的灵活性和Pixi的强大图形处理能力。 Dart是Google开发的一种...
LLVM学习入门(1):Kaleidoscope语言及词法分析
TSWorld
08-17 1071
通过LLVM实现了一个简单的编译器，在学习的过程中加入自己的一些理解笔记。
Kaleidoscope破解版
07-31
MAC上较好用的文件对比工具，MAC上较好用的文件对比工具，MAC上较好用的文件对比工具，MAC上较好用的文件对比工具，MAC上较好用的文件对比工具，MAC上较好用的文件对比工具，MAC上较好用的文件对比工具，MAC上较好用的文件对比工具，MAC上较好用的文件对比工具，MAC上较好用的文件对比工具，MAC上较好用的文件对比工具，
探索LLVM-C之魅力：Kaleidoscope语言实现
gitblog_00045的博客
06-17 309
探索LLVM-C之魅力：Kaleidoscope语言实现 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 llvm-c-kaleidoscope 是一个巧妙的开源项目，它展示了如何使用Flex、Bison和LLVM-C绑定来构建一个简单的解释器。该项目提供了一个叫做Kaleidoscope的语言实例，让用户能够实时体验从输入到执行的过程。只需简单地运行make命令，然后...
kaleidoscope-tutorial:我的中文LLVM教程的第一个语言前端
03-27
万花筒教程 我的中文LLVM教程的第一个语言前端 本系列是，在熟悉的LLVM的开发流程中，网上有一些翻译只有前三个部分，没有翻译全，并且都是四五年前的没有更新过。的概念只停留在理论上，想从代码的角度深入理解一下编译器，希望通过这部分的练习可以帮助到我。记录。 开篇：
Kaleidoscope2.1破解版
10-28
注意事项 如果SourceTree集成Kaleidoscope2.1对比的话,就要安装ksdiff-122目录下的工具, 这样就不会在 SourceTree 配置对比工具的时候出现 Kaleidoscope was not found on this Mac的现象
Sysy2020-llvm-compiler：使用LLVM框架的kaleidoscope语言编译器
02-23
系统 使用LLVM框架的Sysy2020语言编译器 LLVM框架语言：LLVM 12.0.0 编译环境：cmake 3.13 + Deepin 20.1 Beta 编译时若出错请注意LLVM版本号 目前支持程度 函数定义参数 二元表达式 &&，|| +，-，*，/，％，！= 函数调用 传参基础类型，矩阵，多维矩阵传参 条件分支关键字如果 循环关键字 为了 尽管 休息继续 函数返回return保持单入单出特性 全局，局部变量 斑点 尺寸，局部尺寸/多维尺寸 公布定义时初始化 生成AST语法树 生成对应系统架构的目标代码 ...（比较懒，不想写）
LLVM教程2——Kaleidoscope 实现解析器和 AST
再走一步
12-13 715
LLVM官方文档示例2
LLVM学习日志8——Kaleidoscope：添加if和for
tristan_tian的博客
08-18 468
这个是Kaleidoscope的第5章，之前的都只有一个基本块，这是远远不够的。这一章教了if和for。 if比较简单，例子中的if是这样用的，和一般c的不用，if没有括号，多了then。整个if分成三块，if后面的解析表达式，then后面的表达式，else后面的解析表达式。 def fib(x) if x &lt; 3 then 1 else fib(x-1)+fi...
LLVM学习日志3——Kaleidoscope搭建：立志与介绍
tristan_tian的博客
08-12 813
看了一天LLVM的官方文档，看的云里雾里，准备直接上手小例子Kaleidoscope。Kaleidoscope算玩具级别的自定义语言的编译器，英文好的话可以直接看英语版的教程。这也是为我以后修改成熟的LLVM的语言的编译器打下基础。 我也是按照这个英文文档来的，再记录上我自己的想法。这个例子，估计我都要好几周完成。 盗个图说明LLVM的编译器的流程，我们要做的也就是这么几步。先分析代码各个词的...
Kaleidoscope for Mac v4.5 图片和文本差异比较工具
longzu788的博客
05-27 412
Kaleidoscope for Mac是一款专为Mac用户设计的文件和图像比较工具，无疑是当今市场上的一颗璀璨明珠。其强大的功能和直观的可视化界面，使得无论是专业用户还是普通用户，都能轻松驾驭，快速找出文件间的细微差别，从而极大地提高了工作效率。首先，Kaleidoscope提供了多种比较模式，满足了不同用户的需求。其中，并排比较模式让用户可以同时看到两个文件的内容，差异一目了然。
基于llvm自制编译器（4）——代码优化器、JIT编译器
小杨的博客
03-09 1124
前面几章我们介绍了如何实现一门简单的编程语言，同时支持了LLVM IR代码生成。代码优化器JIT编译器至此，我们完成了对 Kaleidoscope 的 JIT 和优化器的支持。我们可以实现一门非图灵完备的编程语言，以用户驱动的方式对齐进行优化和 JIT 编译。后续，我们将研究使用控制流结构扩展编程语言，并在此过程中解决一些 LLVM IR 相关的问题。
LLVM新手入门：Kaleidoscope编译器教程
《20200805-Kaleidoscope（第一期）-孙少策.pdf》是一份针对LLVM新手的入门教程，它详细介绍了如何使用LLVM框架构建一个简单的编译器。Kaleidoscope是一个专注于教学目的的工具，适合对C++编程和编译原理有一定了解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值