cat file.txt | xargs -I {} ./command.sh -p {} -1
find source_dir/ -type f -name "*.cpp" -print0 |xargs -0 wc -l
grep -c "text" filename
orgrep "class" . -Rn
grep -e "class" -e "vitural" file
Use the --include optoin, E.g. just grep in header file (*.h) and source file (*.cpp) grep -rn --include \*.h --include \*.cpp 'word_to_grep' dst/directory/00091 /// Unlike LLVM values, Selection DAG nodes may return multiple 00092 /// values as the result of a computation. Many nodes return multiple values, 00093 /// from loads (which define a token and a return value) to ADDC (which returns 00094 /// a result and a carry value), to calls (which may return an arbitrary number 00095 /// of values). 00096 /// 00097 /// As such, each use of a SelectionDAG computation must indicate the node that 00098 /// computes it as well as which return value to use from that node. This pair 00099 /// of information is represented with the SDValue value type. 00100 /// 00101 class SDValue { 00102 friend struct DenseMapInfo<SDValue>; 00103 00104 SDNode *Node; // The node defining the value we are using. 00105 unsigned ResNo; // Which return value of the node we are using. 00106 public: 00107 SDValue() : Node(nullptr), ResNo(0) {} 00108 SDValue(SDNode *node, unsigned resno); 00109 00110 /// get the index which selects a specific result in the SDNode 00111 unsigned getResNo() const { return ResNo; }
Note, by default the result value is in the the first one, cause we have the default
set "ResNo(0)", knowing this is very important for handling hardware instruction that
has multiple outputs which cannot be handled in .td file (like ADDC, SUBFC ADDIC etc)
find . \( -name "*.txt" -o -name "*.pdf" \) -print
find . ! -name "*.txt" -print
find . -maxdepth 1 -type f
find . -type d -print //只列出所有目录, 这里的d是directory的意思-type f 文件 / l 符号链接
-atime 访问时间 (单位是天，分钟单位则是-amin，以下类似）-mtime 修改时间 （内容被修改）-ctime 变化时间 （元数据或权限变化）
find . -atime 7 -type f -print
find . -type f -name "*.swp" -delete
| Bits | Value |
|---|---|
| 0-5 | 31 |
| 6-10 | S |
| 11-15 | A |
| 16-20 | 00000 |
| 21-30 | 986 |
| 31 | Rc |
| Item | Description |
|---|---|
| RA | Specifies the target general purpose register for the result of the operation. |
| RS | Specifies the source general purpose register for the operand of instruction. |
-O0, -O1, -O2, -O3, -Ofast, -Os, -Oz, -Og, -O, -O4-O0Means “no optimization”: this level compiles the fastest and generates the most debuggable code.
-O1Somewhere between-O0and-O2.
-O2Moderate level of optimization which enables most optimizations.
-O3Like-O2, except that it enables optimizations that take longer to perform or that may generate larger code (in an attempt to make the program run faster).
-OfastEnables all the optimizations from-O3along with other aggressive optimizations that may violate strict compliance with language standards.
-OsLike-O2with extra optimizations to reduce code size.
-OzLike-Os(and thus-O2), but reduces code size further.
-OgLike-O1. In future versions, this option might disable different optimizations in order to improve debuggability.
-OEquivalent to-O2.
-O4and higher
Currently equivalent to-O3
1
2
3
4
5
6
7
8
9
|
#include <algorithm>
#include <cmath>
void abssort(float *x, unsigned N)
{
std::sort(x,
x + N,
[](float a, float b) { return std::abs(a) < std::abs(b); });
从上面的例子来看，尽管支持 lambda 表达式，但 C++ 的语法看起来却很“神奇”。lambda 表达式使用一对方括号作为开始的标识，类似于声明一个函数，只不过这个函数没有名字，也就是一个匿名函数。这个匿名函数接受两个参数，
a和b；其返回值是一个 bool 类型的值，注意，返回值是自动推断的，不需要显式声明，不过这是有条件的！条件就是，lambda 表达式的语句只有一个 return。函数的作用是比较 a、b 的绝对值的大小。然后，在此例中，这个 lambda 表达式作为一个闭包被传递给 std::sort() 函数。 |
1
|
std::cout << [](float f) { return std::abs(f); } (-3.5);
|
std::abs()的返回值就是 float。注意，前面我们也提到了，只有当 lambda 表达式中的语句“足够简单”，才能自动推断返回值类型。
1
2
3
|
function() {} ();
function(a) {} (-3.5);
|
std::abs(float)的返回值是 float，我想把它强制转型为 int。那么，此时，我们就必须显式指定 lambda 表达式返回值的类型：
1
|
std::cout << [](float f) -> int { return std::abs(f); } (-3.5);
|
auto关键字，例如：
1
|
auto lambda = [] () -> int { return val * 100; };
|
auto关键字实际会将 lambda 表达式转换成一种类似于std::function的内部类型（但并不是std::function类型，虽然与std::function“兼容”）。所以，我们也可以这么写：
1
|
std::function<int()> lambda = [] () -> int { return val * 100; };
|
std::function<int()>这种写法感到很神奇，可以查看 C++ 11 的有关std::function的用法。简单来说，std::function<int()>就是一个可调用对象模板类，代表一个可调用对象，接受 0 个参数，返回值是int。所以，当我们需要一个接受一个double作为参数，返回int的对象时，就可以写作：std::function<int(double)>。
1
2
|
float f0 = 1.0;
std::cout << [=](float f) { return f0 + std::abs(f); } (-3.5);
|
1
2
3
|
float f0 = 1.0;
std::cout << [&](float f) { return f0 += std::abs(f); } (-3.5);
std::cout << '\n' << f0 << '\n';
|
1
2
3
|
float f0 = 1.0;
std::cout << [=](float f) mutable { return f0 += std::abs(f); } (-3.5);
std::cout << '\n' << f0 << '\n';
|
[=]意味着，lambda 表达式以传值的形式捕获外部变量。C++ 11 标准说，如果以传值的形式捕获外部变量，那么，lambda 体不允许修改外部变量，对 f0 的任何修改都会引发编译错误。但是，注意，我们在 lambda 表达式前声明了mutable关键字，这就允许了 lambda 表达式体修改 f0 的值。因此，我们的例子本应报错，但是由于有 mutable 关键字，则不会报错。那么，你会觉得输出值是什么呢？答案是，4.5 和 1.0。为什么 f0 还是 1.0？因为我们是传值的，虽然在 lambda 表达式中对 f0 有了修改，但由于是传值的，外部的 f0 依然不会被修改。
1
2
3
4
|
float f0 = 1.0f;
float f1 = 10.0f;
std::cout << [=, &f0](float a) { return f0 += f1 + std::abs(a); } (-3.5);
std::cout << '\n' << f0 << '\n';
|
[] // 不捕获任何外部变量[=] // 以值的形式捕获所有外部变量[&] // 以引用形式捕获所有外部变量[x, &y] // x 以传值形式捕获，y 以引用形式捕获[=, &z]// z 以引用形式捕获，其余变量以传值形式捕获[&, x] // x 以值的形式捕获，其余变量以引用形式捕获[=]或[&]的形式，lambda 表达式可以直接使用 this 指针。但是，对于[]的形式，如果要使用 this 指针，必须显式传入：
1
|
[this]() { this->someFunc(); }();
|
std::sort()或std::for_each()这样的标准函数来尝试使用一下吧！