From c52af453045285f38db199d91dbb4b0e2f21a780 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Mon, 13 Oct 2008 01:59:13 +0000 Subject: [PATCH] calls can be supported. llvm-svn: 57428 --- llvm/lib/CodeGen/SelectionDAG/FastISel.cpp | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/llvm/lib/CodeGen/SelectionDAG/FastISel.cpp b/llvm/lib/CodeGen/SelectionDAG/FastISel.cpp index 77e9bda46f4e..b12665b237aa 100644 --- a/llvm/lib/CodeGen/SelectionDAG/FastISel.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/FastISel.cpp @@ -11,30 +11,30 @@ // // "Fast" instruction selection is designed to emit very poor code quickly. // Also, it is not designed to be able to do much lowering, so most illegal -// types (e.g. i64 on 32-bit targets) and operations (e.g. calls) are not -// supported. It is also not intended to be able to do much optimization, -// except in a few cases where doing optimizations reduces overall compile -// time (e.g. folding constants into immediate fields, because it's cheap -// and it reduces the number of instructions later phases have to examine). +// types (e.g. i64 on 32-bit targets) and operations are not supported. It is +// also not intended to be able to do much optimization, except in a few cases +// where doing optimizations reduces overall compile time. For example, folding +// constants into immediate fields is often done, because it's cheap and it +// reduces the number of instructions later phases have to examine. // // "Fast" instruction selection is able to fail gracefully and transfer // control to the SelectionDAG selector for operations that it doesn't -// support. In many cases, this allows us to avoid duplicating a lot of +// support. In many cases, this allows us to avoid duplicating a lot of // the complicated lowering logic that SelectionDAG currently has. // // The intended use for "fast" instruction selection is "-O0" mode // compilation, where the quality of the generated code is irrelevant when -// weighed against the speed at which the code can be generated. Also, +// weighed against the speed at which the code can be generated. Also, // at -O0, the LLVM optimizers are not running, and this makes the // compile time of codegen a much higher portion of the overall compile -// time. Despite its limitations, "fast" instruction selection is able to +// time. Despite its limitations, "fast" instruction selection is able to // handle enough code on its own to provide noticeable overall speedups // in -O0 compiles. // // Basic operations are supported in a target-independent way, by reading // the same instruction descriptions that the SelectionDAG selector reads, // and identifying simple arithmetic operations that can be directly selected -// from simple operators. More complicated operations currently require +// from simple operators. More complicated operations currently require // target-specific code. // //===----------------------------------------------------------------------===//